web-app-ux-auditor-skill 0.1.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "web-app-ux-auditor",
+  "description": "Web app UI/UX audit skill for React, Next.js, Vue, Svelte, Angular, accessibility, keyboard focus, forms, onboarding, Core Web Vitals, retention, and conversion improvements.",
+  "version": "0.1.0",
+  "author": {
+    "name": "Ajnas"
+  },
+  "license": "MIT",
+  "keywords": [
+    "web",
+    "ui",
+    "ux",
+    "accessibility",
+    "react",
+    "nextjs",
+    "vue",
+    "svelte",
+    "angular"
+  ],
+  "skills": [
+    "./skills/web-app-ux-auditor"
+  ]
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,45 @@
+{
+  "name": "web-app-ux-auditor",
+  "version": "0.1.0",
+  "description": "Agent Skill for auditing and improving web app UI/UX flows across modern frontend stacks.",
+  "author": {
+    "name": "Ajnas",
+    "email": "ajnasnb@gmail.com",
+    "url": "https://github.com/AjnasNB"
+  },
+  "homepage": "https://github.com/AjnasNB/web-app-ux-auditor-skill",
+  "repository": "https://github.com/AjnasNB/web-app-ux-auditor-skill",
+  "license": "MIT",
+  "keywords": [
+    "ux",
+    "ui",
+    "web",
+    "accessibility",
+    "react",
+    "nextjs",
+    "vue",
+    "svelte",
+    "angular",
+    "core-web-vitals"
+  ],
+  "skills": "./skills",
+  "interface": {
+    "displayName": "Web App UX Auditor",
+    "shortDescription": "Audit web app UI/UX flows",
+    "longDescription": "Review and improve web app navigation, onboarding, accessibility, keyboard focus, forms, responsive behavior, Core Web Vitals, retention, conversion, and state handling across modern frontend stacks.",
+    "developerName": "Ajnas",
+    "category": "Development",
+    "capabilities": [
+      "Read",
+      "Write",
+      "Review"
+    ],
+    "websiteURL": "https://github.com/AjnasNB/web-app-ux-auditor-skill",
+    "defaultPrompt": [
+      "Audit this web app UX flow.",
+      "Improve this onboarding flow.",
+      "Review accessibility and Core Web Vitals."
+    ],
+    "brandColor": "#0F766E"
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ajnas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,187 @@
+# Web App UX Auditor Skill
+
+A portable Agent Skill by Ajnas for auditing and improving web app UI/UX flows across React, Next.js, Vue, Nuxt, Svelte, SvelteKit, Angular, Solid, Remix, Astro, and plain HTML/CSS/JavaScript.
+
+Use it when you want an AI coding agent to inspect a web app, map real user flows, find UX friction, and propose or implement improvements with evidence instead of generic "make it cleaner" advice.
+
+## What it helps with
+
+- Navigation, information architecture, route state, browser back/forward, deep links, and re-entry flows.
+- First visit, onboarding, sign-in/sign-up, dashboards, search, checkout, settings, and conversion flows.
+- Forms, validation, autofill, password-manager support, empty/loading/error/offline states.
+- Accessibility: semantic HTML, labels, landmarks, keyboard access, focus management, dialogs, contrast, reduced motion, and screen reader announcements.
+- Responsive behavior across mobile, tablet, desktop, zoomed text, long strings, and RTL/localized content.
+- Performance as UX: Core Web Vitals, LCP, INP, CLS, route transitions, hydration, bundles, and perceived latency.
+- Ethical retention through saved progress, useful reminders, trust, and repeated value.
+- Static code triage with a bundled Python scanner.
+
+## Install globally
+
+```bash
+npx web-app-ux-auditor-skill
+```
+
+The installer asks where to install:
+
+1. Global current user: Claude Code, Codex, and shared Agent Skills.
+2. Current project: local skills plus adapter files for popular coding agents.
+3. Both global and current project.
+4. Custom project path.
+
+Global install copies the skill for the current user into:
+
+- `~/.claude/skills/web-app-ux-auditor`
+- `~/.agents/skills/web-app-ux-auditor`
+- `~/.codex/skills/web-app-ux-auditor`
+
+Restart your agent app after installing.
+
+## Use it
+
+Claude Code:
+
+```text
+/web-app-ux-auditor
+```
+
+Codex:
+
+```text
+$web-app-ux-auditor
+```
+
+Example prompts:
+
+```text
+/web-app-ux-auditor audit the signup and dashboard flow in this Next.js app
+```
+
+```text
+$web-app-ux-auditor review this checkout flow for accessibility, keyboard UX, and Core Web Vitals
+```
+
+## Install into one project
+
+```bash
+npx web-app-ux-auditor-skill --project .
+```
+
+Project install copies the canonical skill into `.claude/skills/` and `.agents/skills/`, then writes adapter rule files for common coding agents:
+
+- Cursor
+- Windsurf
+- GitHub Copilot
+- Gemini
+- Continue
+- Cline
+- Roo Code
+- Kiro
+- Trae
+- OpenCode
+
+Copy only the skill folders and skip adapter files:
+
+```bash
+npx web-app-ux-auditor-skill --project . --no-adapters
+```
+
+Skip prompts and force global install:
+
+```bash
+npx web-app-ux-auditor-skill --yes
+```
+
+## Static scanner
+
+The skill includes a Python scanner for static web UX signals:
+
+```bash
+python scripts/web_ux_static_scan.py /path/to/web-app
+```
+
+The scanner detects review signals such as non-semantic click targets, missing image alt text, placeholder-label risks, missing button types, focus-outline removal, dialog risks, and mobile viewport issues.
+
+It is a triage tool, not a replacement for expert review. Confirm every finding in code, browser, screenshots, accessibility tooling, performance traces, or tests before changing behavior.
+
+## Package layout
+
+```text
+web-app-ux-auditor/
+  SKILL.md
+  agents/openai.yaml
+  references/web-ux-audit-reference.md
+  scripts/web_ux_static_scan.py
+  skills/web-app-ux-auditor/
+  .codex-plugin/plugin.json
+  .claude-plugin/plugin.json
+  bin/install.js
+  package.json
+```
+
+The root `SKILL.md` supports direct skill installation. The `skills/web-app-ux-auditor/` copy supports plugin-style discovery.
+
+## Publish to GitHub
+
+```bash
+gh auth login
+gh repo create AjnasNB/web-app-ux-auditor-skill --public --source . --remote origin --push
+```
+
+If the repo already exists:
+
+```bash
+git remote add origin https://github.com/AjnasNB/web-app-ux-auditor-skill.git
+git push -u origin main
+```
+
+## Download from npm
+
+Install and run without keeping the package:
+
+```bash
+npx web-app-ux-auditor-skill
+```
+
+Install the CLI globally:
+
+```bash
+npm install -g web-app-ux-auditor-skill
+web-app-ux-auditor
+```
+
+## Publish to npm
+
+Log in once:
+
+```bash
+npm adduser
+```
+
+Check the package:
+
+```bash
+npm publish --dry-run --access public
+```
+
+Publish:
+
+```bash
+npm publish --access public
+```
+
+After publishing, users download and install it with:
+
+```bash
+npx web-app-ux-auditor-skill
+```
+
+Or install the CLI globally:
+
+```bash
+npm install -g web-app-ux-auditor-skill
+web-app-ux-auditor --global
+```
+
+## License
+
+MIT

package/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: web-app-ux-auditor
+description: Use when reviewing, redesigning, or implementing web app UI/UX flows in React, Next.js, Vue, Nuxt, Svelte, SvelteKit, Angular, Solid, Remix, Astro, or plain HTML/CSS/JavaScript; especially for navigation, onboarding, dashboards, forms, checkout, accessibility, keyboard focus, responsive behavior, Core Web Vitals, retention, or conversion.
+---
+
+# Web App UX Auditor
+
+## Overview
+
+Audit web apps by tracing real user flows, finding friction with code and runtime evidence, and proposing or implementing improvements that are accessible, responsive, fast, and easy to navigate. Optimize for users completing valuable tasks and returning because the app works well, not because the interface traps or manipulates them.
+
+## Workflow
+
+1. State the design read: app type, audience, job-to-be-done, product maturity, visual register, and risk level. For redesigns, preserve working IA, copy, analytics names, and accessibility wins unless there is evidence they cause harm.
+2. If code is available, run the static signal scan before judging:
+   ```bash
+   python scripts/web_ux_static_scan.py <project-root>
+   ```
+   In Claude Code, use `python ${CLAUDE_SKILL_DIR}/scripts/web_ux_static_scan.py <project-root>` when the skill is installed. Treat the script as evidence-gathering, not a replacement for expert review.
+3. Inspect routing, layouts, components, forms, design tokens, analytics events, accessibility tooling, tests, screenshots, and runtime behavior before recommending changes.
+4. Build a compact route and flow map: first visit, onboarding, sign-in/sign-up, home/dashboard, primary task, search/discovery, form submission, settings, empty/error/loading/offline states, checkout/paywall if present, and return/deep-link flows.
+5. Audit against clarity, information architecture, accessibility, keyboard/focus behavior, forms, responsive layout, performance, trust, feedback, and ethical retention. Load `references/web-ux-audit-reference.md` for the detailed checklist and framework-specific code signals.
+6. Rank findings by user impact:
+   - P0: Blocks a critical task, causes data loss, breaks auth/payment, or creates severe accessibility failure.
+   - P1: Breaks navigation, comprehension, trust, keyboard access, or completion for many users.
+   - P2: Adds avoidable friction, inconsistency, poor responsive behavior, or weak performance.
+   - P3: Polish, content clarity, delight, or instrumentation improvement.
+7. When editing code, preserve the app's architecture and design system. Prefer semantic HTML, native controls, accessible framework primitives, and existing component patterns over custom widgets.
+8. Verify with the best available evidence: local browser walkthrough, Playwright, screenshots, keyboard-only test, screen reader spot-check, Lighthouse/PageSpeed/Core Web Vitals, axe/accessibility checks, unit/component tests, or static inspection. State anything that could not be verified.
+
+## Quality Bar
+
+Hold the output to a senior product design engineer standard:
+
+- The primary user can understand where they are, what changed, what to do next, and how to recover from mistakes.
+- Core flows handle loading, empty, error, partial, disabled, offline, slow-network, auth-expired, and permission-denied states.
+- The UI has one coherent design system: typography scale, spacing rhythm, radius rules, color roles, interaction states, motion, density, and responsive behavior.
+- Accessibility is built into semantics, keyboard behavior, focus management, contrast, target size, status announcements, and reduced-motion behavior.
+- Performance is part of UX: LCP, INP, CLS, route transitions, hydration, bundle size, and perceived latency all matter.
+- Retention comes from saved progress, useful reminders, reduced effort, trust, and repeated value. Do not optimize for addiction.
+
+## Output Format
+
+Start with findings, not praise. Include:
+
+- A prioritized findings table: severity, route/flow, evidence, user impact, recommended fix.
+- A before/after flow summary when IA, onboarding, forms, or checkout changes.
+- Framework-specific implementation notes for React/Next, Vue/Nuxt, Svelte/SvelteKit, Angular, or plain web as applicable.
+- Static scan findings from `scripts/web_ux_static_scan.py` when code is available.
+- Accessibility, keyboard, responsive, and performance checks.
+- Verification performed and remaining risks.
+
+When asked to improve the app directly, implement the smallest high-impact changes first, then report changed files and validation.
+
+## Non-Negotiables
+
+- Do not recommend dark patterns: hidden cancellation, forced continuity, disguised ads, trick opt-ins, guilt copy, confirmshaming, fake scarcity, notification spam, or broken back/close paths.
+- Do not replace semantic HTML with generic `div`/`span` controls unless the accessible behavior is fully implemented and tested.
+- Do not audit only visual polish when code or a runnable app is available.
+- Do not give generic advice like "improve navigation" without naming the exact route, user problem, and change.

package/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Web App UX Auditor"
+  short_description: "Audit and improve web app UI/UX flows"
+  default_prompt: "Use $web-app-ux-auditor to review this web app flow and propose practical UI/UX improvements."

package/bin/install.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const readline = require("readline");
+
+const SKILL_NAME = "web-app-ux-auditor";
+const DISPLAY_NAME = "Web App UX Auditor";
+const DESCRIPTION =
+  "Audit and improve web app UI/UX flows across React, Next.js, Vue, Svelte, Angular, and plain web stacks.";
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const COPY_ENTRIES = ["SKILL.md", "agents", "references", "scripts"];
+
+function usage() {
+  console.log(`
+${DISPLAY_NAME}
+
+Usage:
+  npx web-app-ux-auditor-skill
+  web-app-ux-auditor --global
+  web-app-ux-auditor --project <path>
+  web-app-ux-auditor --targets claude,codex,agents
+
+Default:
+  In an interactive terminal, asks where to install. In non-interactive shells, installs globally.
+
+Options:
+  --global             Install to current-user global skill folders. Default when no mode is passed.
+  --project <path>     Install project-local skills and adapter rule files for popular coding agents.
+  --targets <list>     Comma-separated global targets: claude,codex,agents,codex-legacy.
+  --yes                Skip prompts and install globally.
+  --no-adapters        With --project, skip non-skill adapter files.
+  --print-paths        Print install locations and exit.
+  --help               Show this help.
+`);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function rmIfExists(target) {
+  if (fs.existsSync(target)) {
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+}
+
+function copyEntry(entry, targetDir) {
+  const source = path.join(PACKAGE_ROOT, entry);
+  if (!fs.existsSync(source)) return;
+  const target = path.join(targetDir, entry);
+  rmIfExists(target);
+  fs.cpSync(source, target, { recursive: true });
+}
+
+function copySkillTo(root) {
+  const targetDir = path.join(root, SKILL_NAME);
+  ensureDir(targetDir);
+  for (const entry of COPY_ENTRIES) copyEntry(entry, targetDir);
+  return targetDir;
+}
+
+function globalTargets(selected) {
+  const home = os.homedir();
+  const all = {
+    claude: path.join(home, ".claude", "skills"),
+    agents: path.join(home, ".agents", "skills"),
+    codex: path.join(home, ".agents", "skills"),
+    "codex-legacy": path.join(home, ".codex", "skills")
+  };
+  const names = selected || ["claude", "agents", "codex-legacy"];
+  return [...new Set(names.map((name) => all[name]).filter(Boolean))];
+}
+
+function appendBlock(file, marker, body) {
+  ensureDir(path.dirname(file));
+  const existing = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+  if (existing.includes(marker)) return false;
+  const prefix = existing.trim().length ? `${existing.trimEnd()}\n\n` : "";
+  fs.writeFileSync(file, `${prefix}${body.trimEnd()}\n`, "utf8");
+  return true;
+}
+
+function writeFile(file, content) {
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, content, "utf8");
+}
+
+function adapterText(skillPath) {
+  return `# ${DISPLAY_NAME}
+
+Use the ${SKILL_NAME} Agent Skill for web app UI/UX reviews, redesigns, navigation audits, onboarding, forms, accessibility, keyboard/focus behavior, Core Web Vitals, retention, and conversion improvements.
+
+Canonical skill path in this project: ${skillPath}
+
+Follow the skill workflow before recommending changes:
+- inspect code, routes, layouts, components, forms, design tokens, states, accessibility tooling, and runtime behavior;
+- run the bundled static scanner when code is available;
+- rank findings by user impact;
+- verify with browser walkthroughs, keyboard checks, screenshots, performance data, tests, or static evidence.
+`;
+}
+
+function installProject(projectRoot, withAdapters) {
+  const root = path.resolve(projectRoot);
+  const claudeSkill = copySkillTo(path.join(root, ".claude", "skills"));
+  const agentsSkill = copySkillTo(path.join(root, ".agents", "skills"));
+
+  if (!withAdapters) return [claudeSkill, agentsSkill];
+
+  const marker = `<!-- ${SKILL_NAME}:start -->`;
+  const block = `${marker}
+${adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`)}
+<!-- ${SKILL_NAME}:end -->`;
+
+  writeFile(
+    path.join(root, ".cursor", "rules", `${SKILL_NAME}.mdc`),
+    `---
+description: ${DESCRIPTION}
+globs: **/*
+alwaysApply: false
+---
+
+${adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`)}`
+  );
+  writeFile(path.join(root, ".windsurf", "rules", `${SKILL_NAME}.md`), adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`));
+  writeFile(path.join(root, ".continue", "rules", `${SKILL_NAME}.md`), adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`));
+  writeFile(path.join(root, ".clinerules", `${SKILL_NAME}.md`), adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`));
+  writeFile(path.join(root, ".roo", "rules", `${SKILL_NAME}.md`), adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`));
+  writeFile(path.join(root, ".kiro", "steering", `${SKILL_NAME}.md`), adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`));
+  writeFile(path.join(root, ".trae", "rules", `${SKILL_NAME}.md`), adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`));
+  writeFile(path.join(root, ".opencode", "AGENTS.md"), adapterText(`.agents/skills/${SKILL_NAME}/SKILL.md`));
+
+  appendBlock(path.join(root, "AGENTS.md"), marker, block);
+  appendBlock(path.join(root, ".gemini", "GEMINI.md"), marker, block);
+  appendBlock(path.join(root, ".github", "copilot-instructions.md"), marker, block);
+
+  return [claudeSkill, agentsSkill];
+}
+
+function parseArgs(argv) {
+  const result = {
+    global: false,
+    project: null,
+    targets: null,
+    adapters: true,
+    printPaths: false,
+    help: false,
+    yes: false,
+    explicitMode: false
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") result.help = true;
+    else if (arg === "--global") {
+      result.global = true;
+      result.explicitMode = true;
+    }
+    else if (arg === "--project") {
+      result.project = argv[++i] || ".";
+      result.explicitMode = true;
+    }
+    else if (arg.startsWith("--project=")) {
+      result.project = arg.split("=")[1] || ".";
+      result.explicitMode = true;
+    }
+    else if (arg === "--targets") result.targets = (argv[++i] || "").split(",").map((s) => s.trim()).filter(Boolean);
+    else if (arg.startsWith("--targets=")) result.targets = arg.split("=")[1].split(",").map((s) => s.trim()).filter(Boolean);
+    else if (arg === "--no-adapters") result.adapters = false;
+    else if (arg === "--print-paths") result.printPaths = true;
+    else if (arg === "--yes" || arg === "-y") result.yes = true;
+  }
+  if (result.yes && !result.explicitMode) result.global = true;
+  if (!result.global && !result.project && !process.stdin.isTTY) result.global = true;
+  return result;
+}
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function chooseInstallMode(args) {
+  if (args.global || args.project || args.printPaths || args.help) return args;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    args.global = true;
+    return args;
+  }
+
+  console.log(`${DISPLAY_NAME}`);
+  console.log("");
+  console.log("Where should this skill be installed?");
+  console.log("1. Global current user: Claude Code, Codex, and shared Agent Skills");
+  console.log("2. Current project: .claude/.agents skills plus adapters for Cursor, Windsurf, Copilot, Gemini, Continue, Cline, Roo, Kiro, Trae, OpenCode");
+  console.log("3. Both global current user and current project");
+  console.log("4. Custom project path");
+  console.log("");
+
+  const choice = await ask("Choose 1, 2, 3, or 4 [1]: ");
+  const selected = choice || "1";
+  if (selected === "2") args.project = process.cwd();
+  else if (selected === "3") {
+    args.global = true;
+    args.project = process.cwd();
+  } else if (selected === "4") {
+    const customPath = await ask("Project path: ");
+    args.project = customPath || process.cwd();
+  } else {
+    args.global = true;
+  }
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  await chooseInstallMode(args);
+  if (args.help) {
+    usage();
+    return;
+  }
+
+  if (args.printPaths) {
+    console.log(globalTargets(args.targets).join("\n"));
+    return;
+  }
+
+  const installed = [];
+  if (args.global) {
+    for (const target of globalTargets(args.targets)) {
+      installed.push(copySkillTo(target));
+    }
+  }
+  if (args.project) {
+    installed.push(...installProject(args.project, args.adapters));
+  }
+
+  console.log(`${DISPLAY_NAME} installed:`);
+  for (const target of installed) console.log(`- ${target}`);
+  console.log("");
+  console.log("Claude Code: invoke with /web-app-ux-auditor");
+  console.log("Codex: invoke with $web-app-ux-auditor or let Codex choose it automatically.");
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : String(error));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "web-app-ux-auditor-skill",
+  "version": "0.1.0",
+  "description": "Agent Skill for auditing and improving web app UI/UX flows across modern frontend stacks.",
+  "license": "MIT",
+  "author": {
+    "name": "Ajnas",
+    "email": "ajnasnb@gmail.com"
+  },
+  "type": "commonjs",
+  "bin": {
+    "web-app-ux-auditor": "bin/install.js",
+    "web-app-ux-auditor-skill": "bin/install.js"
+  },
+  "files": [
+    "SKILL.md",
+    "agents/",
+    "references/",
+    "scripts/",
+    "skills/",
+    "bin/",
+    ".codex-plugin/",
+    ".claude-plugin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "agent-skill",
+    "claude-code",
+    "codex",
+    "ux",
+    "ui",
+    "web",
+    "react",
+    "nextjs",
+    "vue",
+    "svelte",
+    "angular",
+    "accessibility",
+    "core-web-vitals"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AjnasNB/web-app-ux-auditor-skill.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AjnasNB/web-app-ux-auditor-skill/issues"
+  },
+  "homepage": "https://github.com/AjnasNB/web-app-ux-auditor-skill#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}