evizi-kit 1.0.0

package/kits/shared/skills/fix-automation-tests/SKILL.md

@@ -0,0 +1,280 @@
+---
+name: fix-automation-tests
+description: Fix web automation test cases when frontend code changes in a PR. Analyzes FE code diff against the automation test codebase, generates an impact report of affected test cases, and fixes them after user confirmation. ALWAYS use this skill when the user mentions fixing, updating, or repairing automation tests due to FE/frontend changes, PR code changes, broken selectors, failing e2e tests after a deploy, or regression from a pull request. Triggers on patterns like "Fix the test cases for the FE code that changed in PR 42", "fix automation tests for PR #123", "update test cases for FE PR 15", "FE code changed in PR 8 fix the tests", "selectors changed and tests are broken", "e2e tests failing after frontend update", "tests broke after merging PR 10", or "update page objects for the new UI". Even if the user doesn't say "automation" explicitly — if they mention broken tests related to FE/UI changes, use this skill.
+---
+
+# Fix Automation Tests
+
+Analyze frontend code changes from a PR, identify affected web automation test cases, generate an impact report, and fix all affected tests after user confirmation.
+
+**Why this skill exists:** Frontend PRs frequently break automation tests by changing selectors, restructuring pages, or altering user flows. Manually hunting down affected tests is tedious and error-prone. This skill systematically cross-references the FE diff against the test codebase so nothing gets missed, then applies targeted fixes that preserve test intent while adapting to the new UI.
+
+## Input Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `PR_NUMBER` | number | Yes | The PR number containing FE code changes |
+
+## Workflow
+
+### Step 1: Read Configuration
+
+Read `.documents-design/project.config.json`. The fetch script needs this to know which platform/repo to pull the PR diff from.
+
+**Required config fields:**
+- `platform` - Git platform (`github`, `gitea`, `gitlab`, `bitbucket`)
+- `platformConfig.{platform}.apiUrl` - API base URL
+- `repos.webApp.{platform}` - FE repository connection details (structure varies by platform, see Configuration section)
+
+**If config missing:** STOP, ask user to create `.documents-design/project.config.json`.
+
+### Step 2: Fetch FE Code Changes
+
+Run the fetch script to pull FE code changes and save to `fe-code-changed.txt`:
+
+```bash
+python3 {SKILL_PATH}/scripts/fetch_pr_changes.py {PR_NUMBER}
+
+# Or target a different repo
+python3 {SKILL_PATH}/scripts/fetch_pr_changes.py {PR_NUMBER} --repo webApp
+```
+
+- `{SKILL_PATH}` is the absolute path to this skill's directory
+- The script reads `platform`, `platformConfig`, and `repos` from `.documents-design/project.config.json` automatically
+- Default repo: `webApp` (configurable via `--repo` flag)
+
+**If script fails:** STOP, show error message to user.
+
+**If script succeeds:** Confirm to user that FE changes were saved, showing line count.
+
+### Step 3: Ask for PR Requirements
+
+Context from the user dramatically improves analysis accuracy. A diff alone can't tell you *why* a page was restructured — but the user often knows the intent, which helps distinguish between "this selector moved" vs "this entire flow was replaced."
+
+Ask the user:
+
+```
+FE code changes saved successfully.
+
+Do you have any requirements or context for this PR? (optional - press Enter to skip)
+Examples: "This PR redesigns the login page layout", "New checkout flow with 3 steps instead of 2"
+```
+
+**If user provides requirements:** Save them to `pr-requirements.md` in the project root and confirm the file was saved.
+
+**If user skips:** Proceed without creating the file.
+
+### Step 4: Analyze Impact
+
+This is the most critical analytical step. A thorough analysis here prevents missed breakages and false positives in the report. The goal is to build a clear mapping: for every meaningful FE change, find every test that touches it.
+
+Read `fe-code-changed.txt` and `pr-requirements.md` (if exists), then work through these three phases:
+
+#### Phase 1: Parse the FE diff
+
+Extract a concrete list of what changed. Don't just skim — be specific:
+- **Selector changes** — old vs new values for class names, IDs, `data-testid`, ARIA labels, `name` attributes
+- **Removed elements** — elements that no longer exist in the DOM
+- **Added elements** — new interactive or assertable elements
+- **Flow changes** — navigation paths, form steps, modal triggers, redirect logic
+- **Text/content changes** — button labels, headings, error messages, placeholder text
+- **URL/route changes** — path changes, query param changes
+- **Component restructuring** — elements moved in the DOM tree (affects ancestor-based selectors like XPath)
+- **API endpoint changes** — if the diff touches API calls used in test data setup
+
+#### Phase 2: Discover existing tests
+
+Search the automation test codebase systematically. Start by identifying the test framework in use, then find all relevant files:
+
+1. **Find test files** — search for patterns like `*.spec.ts`, `*.spec.js`, `*.test.ts`, `*.test.js`, `*Test.java`, `*.feature`, `*_test.py`
+2. **Find Page Objects / page models** — these are the most common place where selectors live. Look for directories named `pages/`, `page-objects/`, `pageObjects/`, `models/`, or files matching `*Page.ts`, `*Page.js`, `*Page.java`
+3. **Find shared utilities** — selector constants, helper functions, fixture files that might reference affected elements
+
+Use grep/search to find references to the specific selectors, text values, and URLs identified in Phase 1. This is more reliable than reading every test file top-to-bottom.
+
+#### Phase 3: Cross-reference
+
+For each FE change from Phase 1, find every test artifact (test file, Page Object, helper) that references it. Build the impact mapping:
+- Which Page Object fields use the changed selector?
+- Which test cases call methods on those Page Objects?
+- Which assertions check the changed text or URL?
+- Which test flows navigate through the changed path?
+
+**Important:** Follow the reference chain. A selector change in a Page Object affects every test that uses that Page Object method — even if the test file itself never mentions the selector directly. Think through the full dependency graph.
+
+**Analysis checklist (verify each):**
+- [ ] Selector changes (class names, IDs, data-testid attributes, ARIA labels)
+- [ ] Element additions or removals
+- [ ] Page flow/navigation changes
+- [ ] Form field changes (added, removed, reordered)
+- [ ] Text content changes used in assertions
+- [ ] URL/route changes
+- [ ] Component restructuring affecting DOM hierarchy
+- [ ] API endpoint changes affecting test data setup
+
+### Step 5: Generate Impact Report
+
+Create `impact-report.md` in the project root using the template at [templates/impact-report.template.md](templates/impact-report.template.md).
+
+The report must include:
+1. **PR Information** - PR number, title, date, and user-provided requirements
+2. **Summary** - Total affected test cases count and files count
+3. **Affected Test Cases Table** - Every affected test case with file path, test name, brief cause, and fix type
+4. **Detailed Analysis** - For each affected test case: the specific FE change that caused the impact and exactly what fix is needed
+
+### Step 6: Present Report for Review
+
+**If no test cases are affected:** Skip report generation, clean up temporary files (`fe-code-changed.txt`, `pr-requirements.md` if exists), and inform the user:
+
+```
+No affected test cases found. The FE changes in PR #{PR_NUMBER} do not impact any existing automation tests.
+
+Cleaned up temporary files.
+```
+
+**If affected test cases are found:** Display the report summary in chat:
+
+```
+Impact Analysis Complete!
+
+PR #{PR_NUMBER} affects {TOTAL_COUNT} test case(s) across {FILE_COUNT} file(s).
+
+Affected Test Cases:
+1. {FILE_PATH} > {TEST_CASE_NAME} - {BRIEF_CAUSE}
+2. {FILE_PATH} > {TEST_CASE_NAME} - {BRIEF_CAUSE}
+...
+
+Full report saved to: impact-report.md
+
+Please review the report. You can:
+- Confirm it is correct, and I will fix all affected test cases
+- Request corrections (e.g., "Test X is not affected", "You missed test Y")
+```
+
+### Step 7: Handle User Feedback Loop
+
+**If user requests corrections:**
+1. Update `impact-report.md` with the corrections
+2. Present the updated report summary again
+3. Ask for confirmation again
+4. Repeat until user confirms
+
+**If user confirms the report is correct:** Proceed to Step 8.
+
+### Step 8: Fix All Affected Test Cases
+
+This is where every test gets fixed. The key principle: **fix at the source, not at every consumer**. If a selector changed, update it once in the Page Object — all tests using that PO method benefit automatically. Avoid duplicating fixes across test files when a single Page Object update solves it.
+
+#### Fix order matters — group and batch
+
+Don't fix test cases one by one in report order. Instead, group them by root cause for efficiency:
+
+1. **Page Object fixes first** — Group all selector/element changes by Page Object. Fix each Page Object once. This automatically resolves every test case that depended on those selectors.
+2. **Shared utilities next** — If helper functions, fixtures, or constants reference changed values, fix those next.
+3. **Individual test files last** — Only now fix test-level changes: flow logic, assertions, added/removed steps. Many of these may already be resolved by the PO fixes above.
+
+#### For each file, follow this process:
+
+1. Read the full file and understand its structure before editing
+2. Identify all changes needed in that file (there may be multiple from different impact items)
+3. Apply all changes to the file at once — don't make multiple passes
+4. Verify the edit is internally consistent (no broken references, no orphaned imports)
+
+#### Fix patterns by type
+
+**Selector Update** — Find the old selector value, replace with the new one. If the project uses a selector strategy (e.g., always `data-testid`), verify the new selector follows the same strategy.
+
+**Flow Change** — Map old flow steps to new ones. If steps were reordered, reorder the test steps to match. If a step was split into multiple steps (e.g., one form became a multi-step wizard), expand the test accordingly. If steps were collapsed, consolidate.
+
+**Assertion Update** — Update expected values to match the new UI. Be careful with partial matches (`toContain` vs `toBe`) — keep the same match strategy unless the change warrants otherwise.
+
+**Element Removed** — Remove the corresponding test step and its assertions. Check if the removal breaks the test flow (e.g., removing a "Next" button click that was needed to advance). If so, replace with the new navigation path.
+
+**Element Added** — Only add test steps for new elements if they are part of an existing test scenario's flow. Don't create entirely new test cases — that's out of scope for this skill.
+
+**Page Restructure** — When the DOM hierarchy changed significantly, Page Object locators using ancestor-based strategies (XPath with parent paths, CSS with deep nesting) may all break. Rewrite the affected locators using the new structure. Prefer resilient selectors (`data-testid`, `role` + `name`) over brittle ones (deep CSS paths, positional XPath).
+
+#### Fix guidelines
+
+- **Preserve test intent** — only change what the FE diff requires. A working test that doesn't touch anything in the diff should never be modified.
+- **Match existing conventions** — use the same selector strategy, assertion style, wait patterns, and naming conventions already in the codebase
+- **Don't add waits/retries speculatively** — only add them if the FE change introduced async behavior where there was none before
+- **Keep imports clean** — if you remove the last usage of an imported PO method or utility, remove the import too
+
+### Step 9: Report Completion
+
+After fixing all test cases, display the summary so the user can review:
+
+```
+All {TOTAL_COUNT} affected test case(s) have been fixed.
+
+Fixed Files:
+- {FILE_PATH_1} ({NUMBER_OF_CHANGES} changes)
+- {FILE_PATH_2} ({NUMBER_OF_CHANGES} changes)
+...
+
+Temporary files kept for reference:
+- fe-code-changed.txt (FE diff)
+- pr-requirements.md (PR context, if created)
+- impact-report.md (impact analysis)
+
+Recommend running the test suite to verify all fixes.
+Once you've confirmed the fixes work, I can clean up the temporary files.
+```
+
+### Step 10: Cleanup (after user confirms fixes work)
+
+Don't clean up automatically — the user may need to reference the diff or report while verifying fixes. Wait for the user to confirm the fixes are working, then remove:
+
+1. Delete `fe-code-changed.txt`
+2. Delete `pr-requirements.md` (if it exists)
+3. Delete `impact-report.md`
+
+If the user doesn't explicitly ask for cleanup, remind them once that temp files remain and can be cleaned up when ready.
+
+## Configuration
+
+Required in `.documents-design/project.config.json`. Add the FE repo under the `repos` map:
+
+```json
+{
+  "platform": "gitea",
+  "platformConfig": {
+    "gitea": { "apiUrl": "https://gitea.example.com/api/v1" }
+  },
+  "repos": {
+    "webApp": {
+      "gitea": { "owner": "your-org", "repo": "your-fe-repo" }
+    }
+  }
+}
+```
+
+### Repo Fields by Platform
+
+| Platform | Fields | Description |
+|----------|--------|-------------|
+| **GitHub** | `owner`, `repo` | Repo owner and name |
+| **Gitea** | `owner`, `repo` | Repo owner and name |
+| **GitLab** | `projectId` | Project ID |
+| **Bitbucket** | `workspace`, `repoSlug` | Workspace and repo slug |
+
+### Platform Authentication
+
+| Platform | Environment Variable |
+|----------|---------------------|
+| GitHub | `GITHUB_TOKEN` |
+| Gitea | `GITEA_TOKEN` |
+| GitLab | `GITLAB_TOKEN` |
+| Bitbucket | `BITBUCKET_USERNAME` + `BITBUCKET_TOKEN` |
+
+## Dependencies
+
+- **Python 3.10+** - For running the fetch script (uses only stdlib, no pip dependencies)
+
+## Resources
+
+| Resource | Path | Purpose |
+|----------|------|---------|
+| Fetch script | `scripts/fetch_pr_changes.py` | Pull FE code changes from a PR |
+| Report template | `templates/impact-report.template.md` | Impact report output format |

package/kits/shared/skills/fix-automation-tests/scripts/fetch_pr_changes.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""Fetch FE code changes from a PR and save to fe-code-changed.txt.
+
+Reads platform and repo config from .documents-design/project.config.json.
+Resolves repo connection details from repos.{repoName}.{platform}.
+Supports GitHub (gh CLI), Gitea, GitLab, and Bitbucket (REST API).
+"""
+
+import argparse
+import base64
+import json
+import os
+import ssl
+
+import sys
+import urllib.request
+import urllib.error
+from datetime import datetime
+from pathlib import Path
+
+OUTPUT_FILE = "fe-code-changed.txt"
+
+CONFIG_LOCATIONS = [".documents-design"]
+
+
+def create_no_proxy_opener():
+    """Create a URL opener that bypasses proxy settings with SSL verification disabled."""
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    return urllib.request.build_opener(
+        urllib.request.ProxyHandler({}),
+        urllib.request.HTTPSHandler(context=ctx)
+    )
+
+
+def find_config() -> dict | None:
+    for directory in CONFIG_LOCATIONS:
+        path = Path(directory) / "project.config.json"
+        if path.exists():
+            with open(path) as f:
+                return json.load(f)
+    return None
+
+
+def fetch_github(pr_number: str, api_url: str, owner: str, repo: str, token: str | None) -> tuple[dict | None, str]:
+    """Fetch PR data using GitHub REST API."""
+    headers = {"Accept": "application/vnd.github.v3.diff"}
+    if token:
+        headers["Authorization"] = f"token {token}"
+    opener = create_no_proxy_opener()
+
+    diff_url = f"{api_url}/repos/{owner}/{repo}/pulls/{pr_number}"
+    req = urllib.request.Request(diff_url, headers=headers)
+    try:
+        with opener.open(req, timeout=60) as resp:
+            diff = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"GitHub API error ({e.code}): {e.reason} - {diff_url}")
+
+    metadata = None
+    meta_headers = {"Accept": "application/vnd.github+json"}
+    if token:
+        meta_headers["Authorization"] = f"token {token}"
+    req = urllib.request.Request(diff_url, headers=meta_headers)
+    try:
+        with opener.open(req, timeout=60) as resp:
+            raw = json.loads(resp.read().decode("utf-8"))
+            metadata = {
+                "title": raw.get("title", "N/A"),
+                "url": raw.get("html_url", "N/A"),
+                "headRefName": raw.get("head", {}).get("ref", "N/A"),
+                "baseRefName": raw.get("base", {}).get("ref", "N/A"),
+            }
+    except (urllib.error.HTTPError, json.JSONDecodeError):
+        pass
+
+    return metadata, diff
+
+
+def fetch_gitea(pr_number: str, api_url: str, owner: str, repo: str, token: str | None) -> tuple[dict | None, str]:
+    """Fetch PR data using Gitea REST API."""
+    headers = {}
+    if token:
+        headers["Authorization"] = f"token {token}"
+    opener = create_no_proxy_opener()
+
+    diff_url = f"{api_url}/repos/{owner}/{repo}/pulls/{pr_number}.diff"
+    req = urllib.request.Request(diff_url, headers=headers)
+    try:
+        with opener.open(req, timeout=60) as resp:
+            diff = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"Gitea API error ({e.code}): {e.reason} - {diff_url}")
+
+    metadata = None
+    meta_url = f"{api_url}/repos/{owner}/{repo}/pulls/{pr_number}"
+    req = urllib.request.Request(meta_url, headers=headers)
+    try:
+        with opener.open(req, timeout=60) as resp:
+            raw = json.loads(resp.read().decode("utf-8"))
+            metadata = {
+                "title": raw.get("title", "N/A"),
+                "url": raw.get("html_url", raw.get("url", "N/A")),
+                "headRefName": raw.get("head", {}).get("ref", "N/A"),
+                "baseRefName": raw.get("base", {}).get("ref", "N/A"),
+            }
+    except (urllib.error.HTTPError, json.JSONDecodeError):
+        pass
+
+    return metadata, diff
+
+
+def fetch_gitlab(pr_number: str, api_url: str, project_id: str, token: str | None) -> tuple[dict | None, str]:
+    """Fetch MR data using GitLab REST API."""
+    headers = {}
+    if token:
+        headers["PRIVATE-TOKEN"] = token
+    opener = create_no_proxy_opener()
+
+    diff_url = f"{api_url}/projects/{project_id}/merge_requests/{pr_number}/diffs"
+    req = urllib.request.Request(diff_url, headers=headers)
+    try:
+        with opener.open(req, timeout=60) as resp:
+            diffs_raw = json.loads(resp.read().decode("utf-8"))
+            diff_lines = []
+            for d in diffs_raw:
+                diff_lines.append(f"diff --git a/{d.get('old_path', '')} b/{d.get('new_path', '')}")
+                diff_lines.append(d.get("diff", ""))
+            diff = "\n".join(diff_lines)
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"GitLab API error ({e.code}): {e.reason}")
+
+    metadata = None
+    meta_url = f"{api_url}/projects/{project_id}/merge_requests/{pr_number}"
+    req = urllib.request.Request(meta_url, headers=headers)
+    try:
+        with opener.open(req, timeout=60) as resp:
+            raw = json.loads(resp.read().decode("utf-8"))
+            metadata = {
+                "title": raw.get("title", "N/A"),
+                "url": raw.get("web_url", "N/A"),
+                "headRefName": raw.get("source_branch", "N/A"),
+                "baseRefName": raw.get("target_branch", "N/A"),
+            }
+    except (urllib.error.HTTPError, json.JSONDecodeError):
+        pass
+
+    return metadata, diff
+
+
+def fetch_bitbucket(pr_number: str, api_url: str, workspace: str, repo_slug: str,
+                    username: str | None, token: str | None) -> tuple[dict | None, str]:
+    """Fetch PR data using Bitbucket REST API."""
+    headers = {}
+    if username and token:
+        credentials = base64.b64encode(f"{username}:{token}".encode()).decode()
+        headers["Authorization"] = f"Basic {credentials}"
+    opener = create_no_proxy_opener()
+
+    diff_url = f"{api_url}/repositories/{workspace}/{repo_slug}/pullrequests/{pr_number}/diff"
+    req = urllib.request.Request(diff_url, headers=headers)
+    try:
+        with opener.open(req, timeout=60) as resp:
+            diff = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"Bitbucket API error ({e.code}): {e.reason} - {diff_url}")
+
+    metadata = None
+    meta_url = f"{api_url}/repositories/{workspace}/{repo_slug}/pullrequests/{pr_number}"
+    req = urllib.request.Request(meta_url, headers=headers)
+    try:
+        with opener.open(req, timeout=60) as resp:
+            raw = json.loads(resp.read().decode("utf-8"))
+            source = raw.get("source", {}).get("branch", {})
+            dest = raw.get("destination", {}).get("branch", {})
+            metadata = {
+                "title": raw.get("title", "N/A"),
+                "url": raw.get("links", {}).get("html", {}).get("href", "N/A"),
+                "headRefName": source.get("name", "N/A"),
+                "baseRefName": dest.get("name", "N/A"),
+            }
+    except (urllib.error.HTTPError, json.JSONDecodeError):
+        pass
+
+    return metadata, diff
+
+
+def write_output(pr_number: str, metadata: dict | None, diff: str):
+    with open(OUTPUT_FILE, "w") as f:
+        f.write("=" * 60 + "\n")
+        f.write(f"PR #{pr_number} - Code Changes\n")
+        f.write("=" * 60 + "\n")
+
+        if metadata:
+            f.write("\n--- PR Metadata ---\n")
+            f.write(f"Title: {metadata.get('title', 'N/A')}\n")
+            f.write(f"URL: {metadata.get('url', 'N/A')}\n")
+            f.write(f"Branch: {metadata.get('headRefName', 'N/A')} -> {metadata.get('baseRefName', 'N/A')}\n")
+            f.write(f"Fetched at: {datetime.now().isoformat()}\n")
+            files = metadata.get("files", [])
+            if files:
+                f.write(f"\nChanged files ({len(files)}):\n")
+                for file_info in files:
+                    path = file_info.get("path", file_info) if isinstance(file_info, dict) else file_info
+                    f.write(f"  - {path}\n")
+
+        f.write("\n--- Diff ---\n")
+        f.write(diff)
+
+    with open(OUTPUT_FILE, "r") as f:
+        line_count = sum(1 for _ in f)
+    return line_count
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fetch FE code changes from a PR")
+    parser.add_argument("pr_number", help="Pull request number")
+    parser.add_argument("--repo", "-r", default="webApp",
+                        help="Repo name from repos map in project.config.json (default: webApp)")
+    args = parser.parse_args()
+
+    config = find_config()
+    if not config:
+        print("Error: project.config.json not found in .documents-design/", file=sys.stderr)
+        sys.exit(1)
+
+    platform = config.get("platform", "github")
+    platform_cfg = config.get("platformConfig", {}).get(platform, {})
+
+    if not platform_cfg:
+        print(f"Error: 'platformConfig.{platform}' is not configured in project.config.json", file=sys.stderr)
+        sys.exit(1)
+
+    repo_config = config.get("repos", {}).get(args.repo, {}).get(platform, {})
+    if not repo_config:
+        print(f"Error: 'repos.{args.repo}.{platform}' is not configured in project.config.json", file=sys.stderr)
+        sys.exit(1)
+
+    api_url = platform_cfg.get("apiUrl", "")
+
+    try:
+        if platform == "github":
+            owner = repo_config.get("owner", "")
+            repo = repo_config.get("repo", "")
+            if not api_url or not owner or not repo:
+                print(f"Error: 'platformConfig.github.apiUrl' and 'repos.{args.repo}.github.owner/repo' are required", file=sys.stderr)
+                sys.exit(1)
+            token = os.environ.get("GITHUB_TOKEN")
+            print(f"Fetching PR #{args.pr_number} from GitHub ({owner}/{repo})...")
+            metadata, diff = fetch_github(args.pr_number, api_url, owner, repo, token)
+
+        elif platform == "gitea":
+            owner = repo_config.get("owner", "")
+            repo = repo_config.get("repo", "")
+            if not api_url or not owner or not repo:
+                print(f"Error: 'platformConfig.gitea.apiUrl' and 'repos.{args.repo}.gitea.owner/repo' are required", file=sys.stderr)
+                sys.exit(1)
+            token = os.environ.get("GITEA_TOKEN")
+            print(f"Fetching PR #{args.pr_number} from Gitea ({owner}/{repo})...")
+            metadata, diff = fetch_gitea(args.pr_number, api_url, owner, repo, token)
+
+        elif platform == "gitlab":
+            project_id = repo_config.get("projectId", "")
+            if not api_url or not project_id:
+                print(f"Error: 'platformConfig.gitlab.apiUrl' and 'repos.{args.repo}.gitlab.projectId' are required", file=sys.stderr)
+                sys.exit(1)
+            token = os.environ.get("GITLAB_TOKEN")
+            print(f"Fetching MR #{args.pr_number} from GitLab (project {project_id})...")
+            metadata, diff = fetch_gitlab(args.pr_number, api_url, project_id, token)
+
+        elif platform == "bitbucket":
+            workspace = repo_config.get("workspace", "")
+            repo_slug = repo_config.get("repoSlug", "")
+            if not api_url or not workspace or not repo_slug:
+                print(f"Error: 'platformConfig.bitbucket.apiUrl' and 'repos.{args.repo}.bitbucket.workspace/repoSlug' are required", file=sys.stderr)
+                sys.exit(1)
+            username = os.environ.get("BITBUCKET_USERNAME")
+            token = os.environ.get("BITBUCKET_TOKEN")
+            print(f"Fetching PR #{args.pr_number} from Bitbucket ({workspace}/{repo_slug})...")
+            metadata, diff = fetch_bitbucket(args.pr_number, api_url, workspace, repo_slug, username, token)
+
+        else:
+            print(f"Error: Unsupported platform '{platform}'", file=sys.stderr)
+            sys.exit(1)
+
+    except RuntimeError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if not diff.strip():
+        print(f"Error: PR #{args.pr_number} has no code changes", file=sys.stderr)
+        sys.exit(1)
+
+    line_count = write_output(args.pr_number, metadata, diff)
+    print(f"Saved PR #{args.pr_number} changes to {OUTPUT_FILE} ({line_count} lines)")
+
+
+if __name__ == "__main__":
+    main()

package/kits/shared/skills/fix-automation-tests/templates/impact-report.template.md

@@ -0,0 +1,42 @@
+# Impact Analysis Report
+
+## PR Information
+
+| Field | Value |
+|-------|-------|
+| **PR Number** | #{PR_NUMBER} |
+| **PR Title** | {PR_TITLE} |
+| **Analysis Date** | {DATE} |
+| **Requirements** | {REQUIREMENTS or "Not provided"} |
+
+## Summary
+
+- **Total Affected Test Cases:** {TOTAL_COUNT}
+- **Test Files Affected:** {FILE_COUNT}
+
+## Affected Test Cases
+
+| # | Test File | Test Case | Cause | Fix Type |
+|---|-----------|-----------|-------|----------|
+| {N} | `{FILE_PATH}` | {TEST_CASE_NAME} | {BRIEF_CAUSE_DESCRIPTION} | {FIX_TYPE} |
+
+### Fix Types Legend
+
+| Type | Description |
+|------|-------------|
+| **Selector Update** | Element selectors changed (class, id, data-testid, etc.) |
+| **Flow Change** | User interaction flow or page navigation changed |
+| **Assertion Update** | Expected values or validation logic changed |
+| **Element Removed** | UI element removed, test step needs removal or replacement |
+| **Element Added** | New UI element added, test needs additional steps |
+| **Page Restructure** | Page layout significantly changed, Page Object needs rewrite |
+| **API Change** | Backend API contract changed affecting test data setup |
+
+## Detailed Analysis
+
+### {N}. {TEST_FILE_PATH}
+
+**Test Case:** `{TEST_CASE_NAME}`
+**Cause:** {DETAILED_DESCRIPTION_OF_WHY_THIS_TEST_IS_AFFECTED}
+**FE Change:** {SPECIFIC_FE_CODE_CHANGE_THAT_CAUSED_THE_IMPACT}
+**Fix Required:** {DESCRIPTION_OF_WHAT_NEEDS_TO_CHANGE_IN_THE_TEST}