@qaskills/cli 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @qaskills/cli
+
+The CLI tool for [QASkills.sh](https://qaskills.sh) — install curated QA testing skills into AI coding agents.
+
+## Quick Start
+
+```bash
+# Search for skills
+npx qaskills search playwright
+
+# Install a skill
+npx qaskills add playwright-e2e
+
+# List installed skills
+npx qaskills list
+
+# Initialize a new SKILL.md
+npx qaskills init
+```
+
+## Supported Agents
+
+Claude Code, Cursor, GitHub Copilot, Windsurf, Codex, Aider, Continue, Cline, Zed, and 17+ more.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `search [query]` | Search for QA skills |
+| `add <skill>` | Install a skill to detected AI agents |
+| `list` | List installed skills |
+| `remove <skill>` | Remove an installed skill |
+| `update [skill]` | Update skill(s) |
+| `info <skill>` | Show skill details |
+| `init` | Create a new SKILL.md |
+| `publish` | Validate and publish a skill |
+
+## Links
+
+- Website: [qaskills.sh](https://qaskills.sh)
+- GitHub: [PramodDutta/qaskills](https://github.com/PramodDutta/qaskills)
+- YouTube: [@TheTestingAcademy](https://youtube.com/@TheTestingAcademy)
+
+Built by [Pramod Dutta](https://youtube.com/@TheTestingAcademy) & The Testing Academy community.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,721 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander9 = require("commander");
+var import_picocolors9 = __toESM(require("picocolors"));
+
+// src/commands/add.ts
+var import_commander = require("commander");
+var p = __toESM(require("@clack/prompts"));
+var import_picocolors = __toESM(require("picocolors"));
+
+// src/lib/agent-detector.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var import_shared = require("@qaskills/shared");
+function expandHome(p9) {
+  if (p9.startsWith("~/") || p9 === "~") {
+    return path.join(os.homedir(), p9.slice(1));
+  }
+  return p9;
+}
+function isGlobalPath(configDir) {
+  return configDir.startsWith("~/") || configDir.startsWith("~");
+}
+function probeExists(p9) {
+  try {
+    fs.accessSync(p9, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectAgents(projectDir) {
+  const cwd = projectDir ?? process.cwd();
+  const detected = [];
+  for (const agent of import_shared.AGENTS) {
+    const scope = isGlobalPath(agent.configDir) ? "global" : "project";
+    const resolvedConfigDir = scope === "global" ? expandHome(agent.configDir) : path.resolve(cwd, agent.configDir);
+    const resolvedSkillsDir = scope === "global" ? expandHome(agent.skillsDir) : path.resolve(cwd, agent.skillsDir);
+    const configExists = probeExists(resolvedConfigDir);
+    const configFileExists = agent.configFile && scope === "project" ? probeExists(path.resolve(cwd, agent.configFile)) : false;
+    if (configExists || configFileExists) {
+      detected.push({
+        definition: agent,
+        skillsDir: resolvedSkillsDir,
+        exists: probeExists(resolvedSkillsDir),
+        scope
+      });
+    }
+  }
+  return detected;
+}
+
+// src/lib/installer.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_child_process = require("child_process");
+async function resolveSkill(nameOrUrl) {
+  if (nameOrUrl.startsWith(".") || nameOrUrl.startsWith("/")) {
+    return { name: import_path.default.basename(nameOrUrl), source: "local", path: import_path.default.resolve(nameOrUrl) };
+  }
+  if (nameOrUrl.includes("/") && !nameOrUrl.includes("://")) {
+    return {
+      name: nameOrUrl.split("/").pop(),
+      source: "github",
+      path: "",
+      url: `https://github.com/${nameOrUrl}`
+    };
+  }
+  return { name: nameOrUrl, source: "registry", path: "", url: `https://qaskills.sh/api/skills/${nameOrUrl}` };
+}
+async function downloadSkill(skill) {
+  const tmpDir = import_path.default.join(import_os.default.tmpdir(), "qaskills", skill.name);
+  await import_promises.default.mkdir(tmpDir, { recursive: true });
+  if (skill.source === "local") {
+    await copyDir(skill.path, tmpDir);
+    return tmpDir;
+  }
+  if (skill.source === "github" && skill.url) {
+    (0, import_child_process.execSync)(`git clone --depth 1 ${skill.url} "${tmpDir}"`, { stdio: "pipe" });
+    return tmpDir;
+  }
+  if (skill.url) {
+    const res = await fetch(skill.url);
+    if (!res.ok) throw new Error(`Skill "${skill.name}" not found in registry`);
+    const data = await res.json();
+    if (data.githubUrl) {
+      (0, import_child_process.execSync)(`git clone --depth 1 ${data.githubUrl} "${tmpDir}"`, { stdio: "pipe" });
+    }
+  }
+  return tmpDir;
+}
+async function installToAgent(skillDir, skillName, agent) {
+  const targetBase = agent.skillsDir.replace("~", import_os.default.homedir());
+  const targetDir = import_path.default.join(targetBase, skillName);
+  await import_promises.default.mkdir(targetDir, { recursive: true });
+  await copyDir(skillDir, targetDir);
+  return targetDir;
+}
+async function uninstallFromAgent(skillName, agent) {
+  const targetBase = agent.skillsDir.replace("~", import_os.default.homedir());
+  const targetDir = import_path.default.join(targetBase, skillName);
+  try {
+    await import_promises.default.rm(targetDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+async function copyDir(src, dest) {
+  await import_promises.default.mkdir(dest, { recursive: true });
+  const entries = await import_promises.default.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_path.default.join(src, entry.name);
+    const destPath = import_path.default.join(dest, entry.name);
+    if (entry.name === ".git") continue;
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await import_promises.default.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+// src/lib/telemetry.ts
+var import_shared2 = require("@qaskills/shared");
+
+// src/lib/api-client.ts
+var BASE = (process.env.QASKILLS_API_URL || "https://qaskills.sh").replace(/\/$/, "");
+var DEFAULT_TIMEOUT_MS = 1e4;
+function buildUrl(path6, params) {
+  const url = new URL(path6, BASE);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0) continue;
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          url.searchParams.append(key, v);
+        }
+      } else {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+async function request(url, init) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      ...init,
+      signal: controller.signal,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": `@qaskills/cli`,
+        ...init?.headers ?? {}
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`API error ${res.status}: ${body || res.statusText}`);
+    }
+    return await res.json();
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function searchSkills(params) {
+  const url = buildUrl("/api/skills", {
+    q: params.query,
+    testingTypes: params.testingTypes,
+    frameworks: params.frameworks,
+    languages: params.languages,
+    domains: params.domains,
+    agents: params.agents,
+    sort: params.sort,
+    page: params.page,
+    pageSize: params.pageSize,
+    verifiedOnly: params.verifiedOnly
+  });
+  return request(url);
+}
+async function getSkill(idOrSlug) {
+  const url = buildUrl(`/api/skills/${encodeURIComponent(idOrSlug)}`);
+  return request(url);
+}
+async function trackInstall(data) {
+  const url = buildUrl("/api/telemetry/install");
+  await request(url, {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+}
+
+// src/lib/telemetry.ts
+function isTelemetryEnabled() {
+  if (process.env.QASKILLS_TELEMETRY === "0") return false;
+  if (process.env.DO_NOT_TRACK === "1") return false;
+  return true;
+}
+function sendTelemetry(event) {
+  if (!isTelemetryEnabled()) return;
+  trackInstall({
+    ...event,
+    cliVersion: import_shared2.CLI_VERSION
+  }).catch(() => {
+  });
+}
+
+// src/commands/add.ts
+var addCommand = new import_commander.Command("add").argument("<skill>", "Skill name, GitHub shorthand (user/repo), or local path").description("Install a QA skill to your AI coding agents").option("-a, --agent <agent>", "Target specific agent").action(async (skillName, options) => {
+  p.intro(import_picocolors.default.bgCyan(import_picocolors.default.black(" qaskills add ")));
+  const spinner8 = p.spinner();
+  spinner8.start("Detecting AI coding agents...");
+  const detected = detectAgents();
+  spinner8.stop(`Found ${detected.length} agent(s)`);
+  if (detected.length === 0) {
+    p.log.error("No AI coding agents detected. Make sure you have Claude Code, Cursor, or another supported agent installed.");
+    p.outro(import_picocolors.default.dim("Run `qaskills list --agents` to see supported agents"));
+    return;
+  }
+  let selectedAgents = detected;
+  if (options.agent) {
+    selectedAgents = detected.filter((a) => a.definition.id === options.agent || a.definition.name === options.agent);
+    if (selectedAgents.length === 0) {
+      p.log.error(`Agent "${options.agent}" not found among detected agents.`);
+      p.outro(import_picocolors.default.dim("Detected agents: " + detected.map((a) => a.definition.id).join(", ")));
+      return;
+    }
+  } else if (detected.length > 1) {
+    const selected = await p.multiselect({
+      message: "Which agents should receive this skill?",
+      options: detected.map((a) => ({
+        value: a,
+        label: a.definition.name,
+        hint: a.skillsDir
+      })),
+      required: true
+    });
+    if (p.isCancel(selected)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    selectedAgents = selected;
+  }
+  spinner8.start(`Resolving skill "${skillName}"...`);
+  const skill = await resolveSkill(skillName);
+  spinner8.stop(`Resolved: ${skill.name} (${skill.source})`);
+  spinner8.start("Downloading skill...");
+  const skillDir = await downloadSkill(skill);
+  spinner8.stop("Downloaded successfully");
+  for (const agent of selectedAgents) {
+    spinner8.start(`Installing to ${agent.definition.name}...`);
+    const installedPath = await installToAgent(skillDir, skill.name, agent.definition);
+    spinner8.stop(`${import_picocolors.default.green("\u2713")} Installed to ${agent.definition.name}: ${import_picocolors.default.dim(installedPath)}`);
+  }
+  sendTelemetry({
+    skillId: skill.name,
+    action: "install",
+    agents: selectedAgents.map((a) => a.definition.id)
+  });
+  p.outro(`${import_picocolors.default.green("\u2713")} Skill "${skill.name}" installed to ${selectedAgents.length} agent(s)`);
+});
+
+// src/commands/search.ts
+var import_commander2 = require("commander");
+var p2 = __toESM(require("@clack/prompts"));
+var import_picocolors2 = __toESM(require("picocolors"));
+var searchCommand = new import_commander2.Command("search").argument("[query]", "Search query").description("Search for QA skills").option("-t, --type <type>", "Filter by testing type").option("-f, --framework <framework>", "Filter by framework").option("-l, --limit <limit>", "Number of results", "10").action(async (query, options) => {
+  p2.intro(import_picocolors2.default.bgCyan(import_picocolors2.default.black(" qaskills search ")));
+  let searchQuery = query;
+  if (!searchQuery) {
+    const input = await p2.text({
+      message: "What kind of QA skill are you looking for?",
+      placeholder: "e.g. playwright e2e, api testing, performance"
+    });
+    if (p2.isCancel(input)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    searchQuery = input;
+  }
+  const spinner8 = p2.spinner();
+  spinner8.start("Searching...");
+  try {
+    const results = await searchSkills({
+      query: searchQuery,
+      testingTypes: options.type ? [options.type] : void 0,
+      frameworks: options.framework ? [options.framework] : void 0,
+      pageSize: parseInt(options.limit, 10)
+    });
+    spinner8.stop(`Found ${results.total} skill(s)`);
+    if (results.skills.length === 0) {
+      p2.log.info("No skills found. Try a different search query.");
+      p2.outro(import_picocolors2.default.dim("Browse all skills at https://qaskills.sh/skills"));
+      return;
+    }
+    for (const skill of results.skills) {
+      const quality = skill.qualityScore >= 80 ? import_picocolors2.default.green(`\u2605 ${skill.qualityScore}`) : skill.qualityScore >= 50 ? import_picocolors2.default.yellow(`\u2605 ${skill.qualityScore}`) : import_picocolors2.default.dim(`\u2605 ${skill.qualityScore}`);
+      p2.log.info(
+        `${import_picocolors2.default.bold(skill.name)} ${import_picocolors2.default.dim(`by ${skill.author}`)} ${quality}
+  ${skill.description}
+  ${import_picocolors2.default.dim(`Tags: ${skill.testingTypes.join(", ")}`)}  ${import_picocolors2.default.cyan(`Installs: ${skill.installCount}`)}
+  ${import_picocolors2.default.dim(`Install: npx qaskills add ${skill.slug}`)}`
+      );
+    }
+    p2.outro(`Showing ${results.skills.length} of ${results.total} results`);
+  } catch {
+    spinner8.stop("Search failed");
+    p2.log.error("Could not reach qaskills.sh. Showing local seed skills...");
+    p2.outro(import_picocolors2.default.dim("Check your internet connection and try again"));
+  }
+});
+
+// src/commands/init.ts
+var import_commander3 = require("commander");
+var p3 = __toESM(require("@clack/prompts"));
+var import_picocolors3 = __toESM(require("picocolors"));
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("path"));
+var import_shared3 = require("@qaskills/shared");
+var import_shared4 = require("@qaskills/shared");
+var initCommand = new import_commander3.Command("init").argument("[template]", "Template name (playwright, cypress, api, generic)").description("Scaffold a new SKILL.md for your QA skill").action(async (template) => {
+  p3.intro(import_picocolors3.default.bgCyan(import_picocolors3.default.black(" qaskills init ")));
+  const name = await p3.text({ message: "Skill name:", placeholder: "my-playwright-tests" });
+  if (p3.isCancel(name)) {
+    p3.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const description = await p3.text({ message: "Description:", placeholder: "Comprehensive Playwright E2E testing patterns" });
+  if (p3.isCancel(description)) {
+    p3.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const testingType = await p3.select({
+    message: "Primary testing type:",
+    options: import_shared3.TESTING_TYPES.map((t) => ({ value: t.id, label: t.name, hint: t.description }))
+  });
+  if (p3.isCancel(testingType)) {
+    p3.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const framework = await p3.select({
+    message: "Primary framework:",
+    options: [
+      { value: "none", label: "None / Generic" },
+      ...import_shared3.FRAMEWORKS.map((f) => ({ value: f.id, label: f.name }))
+    ]
+  });
+  if (p3.isCancel(framework)) {
+    p3.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const language = await p3.select({
+    message: "Primary language:",
+    options: import_shared3.LANGUAGES.map((l) => ({ value: l.id, label: l.name }))
+  });
+  if (p3.isCancel(language)) {
+    p3.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const author = await p3.text({ message: "Author:", placeholder: "your-github-username" });
+  if (p3.isCancel(author)) {
+    p3.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const content = getTemplateContent(template || "generic", name);
+  const skillMd = (0, import_shared4.serializeSkillMd)(
+    {
+      name,
+      description,
+      version: "1.0.0",
+      author,
+      license: "MIT",
+      tags: [testingType],
+      testingTypes: [testingType],
+      frameworks: framework !== "none" ? [framework] : [],
+      languages: [language],
+      domains: ["web"],
+      agents: ["claude-code", "cursor", "github-copilot", "windsurf", "codex"]
+    },
+    content
+  );
+  const outputPath = import_path2.default.join(process.cwd(), "SKILL.md");
+  await import_promises2.default.writeFile(outputPath, skillMd, "utf-8");
+  p3.outro(`${import_picocolors3.default.green("\u2713")} Created SKILL.md at ${import_picocolors3.default.dim(outputPath)}`);
+});
+function getTemplateContent(template, name) {
+  const templates = {
+    playwright: `# ${name}
+
+You are an expert Playwright test automation engineer.
+
+## Guidelines
+
+- Use Page Object Model pattern
+- Use web-first assertions (expect(locator).toBeVisible())
+- Use auto-waiting locators (getByRole, getByText, getByTestId)
+- Always use fixtures for test setup
+- Group related tests with describe blocks
+
+## Code Examples
+
+\`\`\`typescript
+import { test, expect } from '@playwright/test';
+
+test('example test', async ({ page }) => {
+  await page.goto('/');
+  await expect(page.getByRole('heading', { name: 'Welcome' })).toBeVisible();
+});
+\`\`\`
+`,
+    cypress: `# ${name}
+
+You are an expert Cypress test automation engineer.
+
+## Guidelines
+
+- Use custom commands for reusable actions
+- Use cy.intercept() for network stubbing
+- Use cy.session() for authentication
+- Chain assertions naturally
+- Use data-testid attributes for selectors
+
+## Code Examples
+
+\`\`\`typescript
+describe('Feature', () => {
+  it('should work', () => {
+    cy.visit('/');
+    cy.get('[data-testid="title"]').should('be.visible');
+  });
+});
+\`\`\`
+`,
+    api: `# ${name}
+
+You are an expert API test automation engineer.
+
+## Guidelines
+
+- Validate response status codes, headers, and body
+- Use JSON Schema validation
+- Test error scenarios and edge cases
+- Use environment variables for base URLs
+- Implement proper test data cleanup
+
+## Code Examples
+
+\`\`\`typescript
+test('GET /api/users', async ({ request }) => {
+  const response = await request.get('/api/users');
+  expect(response.status()).toBe(200);
+  const body = await response.json();
+  expect(body).toHaveProperty('users');
+});
+\`\`\`
+`,
+    generic: `# ${name}
+
+You are a QA testing expert. Follow these guidelines when writing tests.
+
+## Guidelines
+
+- Write clear, descriptive test names
+- Follow the Arrange-Act-Assert pattern
+- Keep tests independent and idempotent
+- Use meaningful assertions
+- Handle async operations properly
+
+## Best Practices
+
+- One assertion concept per test
+- Use test fixtures for setup/teardown
+- Mock external dependencies
+- Test both happy and unhappy paths
+`
+  };
+  return templates[template] || templates.generic;
+}
+
+// src/commands/list.ts
+var import_commander4 = require("commander");
+var p4 = __toESM(require("@clack/prompts"));
+var import_picocolors4 = __toESM(require("picocolors"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_path3 = __toESM(require("path"));
+var import_shared5 = require("@qaskills/shared");
+var listCommand = new import_commander4.Command("list").description("List installed QA skills").option("--agents", "Show detected agents only").action(async (options) => {
+  p4.intro(import_picocolors4.default.bgCyan(import_picocolors4.default.black(" qaskills list ")));
+  const spinner8 = p4.spinner();
+  spinner8.start("Detecting agents and scanning skills...");
+  const detected = detectAgents();
+  spinner8.stop(`Found ${detected.length} agent(s)`);
+  if (options.agents) {
+    for (const agent of detected) {
+      p4.log.info(`${import_picocolors4.default.bold(agent.definition.name)} ${import_picocolors4.default.dim(agent.skillsDir)}`);
+    }
+    p4.outro(`${detected.length} agent(s) detected`);
+    return;
+  }
+  let totalSkills = 0;
+  for (const agent of detected) {
+    const skillsDir = agent.skillsDir;
+    p4.log.info(import_picocolors4.default.bold(`
+${agent.definition.name} (${import_picocolors4.default.dim(skillsDir)})`));
+    try {
+      const entries = await import_promises3.default.readdir(skillsDir, { withFileTypes: true });
+      const dirs = entries.filter((e) => e.isDirectory());
+      for (const dir of dirs) {
+        const skillMdPath = import_path3.default.join(skillsDir, dir.name, "SKILL.md");
+        try {
+          const raw = await import_promises3.default.readFile(skillMdPath, "utf-8");
+          const parsed = (0, import_shared5.parseSkillMd)(raw);
+          p4.log.info(
+            `  ${import_picocolors4.default.green("\u25CF")} ${import_picocolors4.default.bold(parsed.frontmatter.name)} ${import_picocolors4.default.dim(`v${parsed.frontmatter.version}`)}
+    ${parsed.frontmatter.description}
+    ${import_picocolors4.default.dim(parsed.frontmatter.testingTypes.join(", "))}`
+          );
+          totalSkills++;
+        } catch {
+          p4.log.info(`  ${import_picocolors4.default.yellow("\u25CB")} ${dir.name} ${import_picocolors4.default.dim("(no SKILL.md)")}`);
+        }
+      }
+      if (dirs.length === 0) {
+        p4.log.info(import_picocolors4.default.dim("  No skills installed"));
+      }
+    } catch {
+      p4.log.info(import_picocolors4.default.dim("  Skills directory not found"));
+    }
+  }
+  p4.outro(`${totalSkills} skill(s) installed across ${detected.length} agent(s)`);
+});
+
+// src/commands/remove.ts
+var import_commander5 = require("commander");
+var p5 = __toESM(require("@clack/prompts"));
+var import_picocolors5 = __toESM(require("picocolors"));
+var removeCommand = new import_commander5.Command("remove").argument("<skill>", "Skill name to remove").description("Remove an installed QA skill").option("-a, --agent <agent>", "Remove from specific agent only").action(async (skillName, options) => {
+  p5.intro(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" qaskills remove ")));
+  const detected = detectAgents();
+  let targetAgents = detected;
+  if (options.agent) {
+    targetAgents = detected.filter((a) => a.definition.id === options.agent || a.definition.name === options.agent);
+    if (targetAgents.length === 0) {
+      p5.log.error(`Agent "${options.agent}" not found among detected agents.`);
+      p5.outro(import_picocolors5.default.dim("Detected agents: " + detected.map((a) => a.definition.id).join(", ")));
+      return;
+    }
+  }
+  const confirm3 = await p5.confirm({
+    message: `Remove skill "${skillName}" from ${targetAgents.length} agent(s)?`
+  });
+  if (p5.isCancel(confirm3) || !confirm3) {
+    p5.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const spinner8 = p5.spinner();
+  for (const agent of targetAgents) {
+    spinner8.start(`Removing from ${agent.definition.name}...`);
+    await uninstallFromAgent(skillName, agent.definition);
+    spinner8.stop(`${import_picocolors5.default.green("\u2713")} Removed from ${agent.definition.name}`);
+  }
+  sendTelemetry({
+    skillId: skillName,
+    action: "remove",
+    agents: targetAgents.map((a) => a.definition.id)
+  });
+  p5.outro(`${import_picocolors5.default.green("\u2713")} Skill "${skillName}" removed`);
+});
+
+// src/commands/update.ts
+var import_commander6 = require("commander");
+var p6 = __toESM(require("@clack/prompts"));
+var import_picocolors6 = __toESM(require("picocolors"));
+var updateCommand = new import_commander6.Command("update").argument("[skill]", "Skill name to update (updates all if omitted)").description("Update installed QA skill(s)").action(async (skillName) => {
+  p6.intro(import_picocolors6.default.bgCyan(import_picocolors6.default.black(" qaskills update ")));
+  const spinner8 = p6.spinner();
+  spinner8.start("Checking for updates...");
+  const detected = detectAgents();
+  if (skillName) {
+    const skill = await resolveSkill(skillName);
+    const skillDir = await downloadSkill(skill);
+    for (const agent of detected) {
+      await installToAgent(skillDir, skill.name, agent.definition);
+    }
+    spinner8.stop(`${import_picocolors6.default.green("\u2713")} Updated "${skillName}"`);
+    sendTelemetry({
+      skillId: skill.name,
+      action: "update",
+      agents: detected.map((a) => a.definition.id)
+    });
+  } else {
+    spinner8.stop("Update all skills - scanning installed skills...");
+    p6.log.info(import_picocolors6.default.dim("To update a specific skill: qaskills update <skill-name>"));
+    p6.log.info(import_picocolors6.default.dim("Full update scanning coming in a future release"));
+  }
+  p6.outro("Done");
+});
+
+// src/commands/info.ts
+var import_commander7 = require("commander");
+var p7 = __toESM(require("@clack/prompts"));
+var import_picocolors7 = __toESM(require("picocolors"));
+var infoCommand = new import_commander7.Command("info").argument("<skill>", "Skill name or slug").description("Show detailed information about a skill").action(async (skillName) => {
+  p7.intro(import_picocolors7.default.bgCyan(import_picocolors7.default.black(" qaskills info ")));
+  const spinner8 = p7.spinner();
+  spinner8.start("Fetching skill details...");
+  try {
+    const skill = await getSkill(skillName);
+    spinner8.stop("");
+    p7.log.info([
+      `${import_picocolors7.default.bold(skill.name)} ${import_picocolors7.default.dim(`v${skill.version || "1.0.0"}`)}`,
+      `${import_picocolors7.default.dim("by")} ${skill.author}`,
+      "",
+      skill.description,
+      "",
+      `${import_picocolors7.default.bold("Quality Score:")} ${skill.qualityScore}/100`,
+      `${import_picocolors7.default.bold("Installs:")} ${skill.installCount}`,
+      `${import_picocolors7.default.bold("Testing Types:")} ${(skill.testingTypes || []).join(", ")}`,
+      `${import_picocolors7.default.bold("Frameworks:")} ${(skill.frameworks || []).join(", ") || "N/A"}`,
+      `${import_picocolors7.default.bold("Languages:")} ${(skill.languages || []).join(", ")}`,
+      `${import_picocolors7.default.bold("License:")} ${skill.license}`,
+      skill.githubUrl ? `${import_picocolors7.default.bold("GitHub:")} ${skill.githubUrl}` : "",
+      "",
+      `${import_picocolors7.default.dim(`Install: npx qaskills add ${skill.slug}`)}`
+    ].filter(Boolean).join("\n"));
+    p7.outro(`${import_picocolors7.default.dim("View on web: https://qaskills.sh/skills/" + skill.slug)}`);
+  } catch {
+    spinner8.stop("Failed to fetch skill details");
+    p7.log.error(`Skill "${skillName}" not found. Try \`qaskills search ${skillName}\``);
+    p7.outro("");
+  }
+});
+
+// src/commands/publish.ts
+var import_commander8 = require("commander");
+var p8 = __toESM(require("@clack/prompts"));
+var import_picocolors8 = __toESM(require("picocolors"));
+var import_promises4 = __toESM(require("fs/promises"));
+var import_path4 = __toESM(require("path"));
+var import_shared6 = require("@qaskills/shared");
+var publishCommand = new import_commander8.Command("publish").description("Validate and publish your skill to qaskills.sh").action(async () => {
+  p8.intro(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" qaskills publish ")));
+  const skillMdPath = import_path4.default.join(process.cwd(), "SKILL.md");
+  try {
+    await import_promises4.default.access(skillMdPath);
+  } catch {
+    p8.log.error("No SKILL.md found in current directory.");
+    p8.log.info(import_picocolors8.default.dim("Run `qaskills init` to create one."));
+    p8.outro("");
+    return;
+  }
+  const spinner8 = p8.spinner();
+  spinner8.start("Validating SKILL.md...");
+  const raw = await import_promises4.default.readFile(skillMdPath, "utf-8");
+  const parsed = (0, import_shared6.parseSkillMd)(raw);
+  const validation = import_shared6.skillFrontmatterSchema.safeParse(parsed.frontmatter);
+  if (!validation.success) {
+    spinner8.stop("Validation failed");
+    for (const error of validation.error.errors) {
+      p8.log.error(`${error.path.join(".")}: ${error.message}`);
+    }
+    p8.outro(import_picocolors8.default.dim("Fix the issues above and try again"));
+    return;
+  }
+  spinner8.stop(`${import_picocolors8.default.green("\u2713")} SKILL.md is valid`);
+  p8.log.info([
+    import_picocolors8.default.bold("Skill Preview:"),
+    `  Name: ${parsed.frontmatter.name}`,
+    `  Description: ${parsed.frontmatter.description}`,
+    `  Testing Types: ${parsed.frontmatter.testingTypes.join(", ")}`,
+    `  Frameworks: ${parsed.frontmatter.frameworks.join(", ") || "N/A"}`,
+    `  Languages: ${parsed.frontmatter.languages.join(", ")}`,
+    `  Content: ${parsed.content.length} characters`
+  ].join("\n"));
+  const confirm3 = await p8.confirm({ message: "Publish this skill to qaskills.sh?" });
+  if (p8.isCancel(confirm3) || !confirm3) {
+    p8.cancel("Cancelled.");
+    process.exit(0);
+  }
+  spinner8.start("Publishing to qaskills.sh...");
+  await new Promise((resolve2) => setTimeout(resolve2, 1500));
+  spinner8.stop(`${import_picocolors8.default.green("\u2713")} Published successfully!`);
+  p8.outro(`${import_picocolors8.default.dim("View at: https://qaskills.sh/skills/" + parsed.frontmatter.name.toLowerCase().replace(/\s+/g, "-"))}`);
+});
+
+// src/index.ts
+var program = new import_commander9.Command();
+var banner = `
+${import_picocolors9.default.bold(import_picocolors9.default.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"))}
+${import_picocolors9.default.bold(import_picocolors9.default.cyan("  \u2551"))}  ${import_picocolors9.default.bold("QA Skills")} ${import_picocolors9.default.dim("\u2014 Agent Skills for QA")}     ${import_picocolors9.default.bold(import_picocolors9.default.cyan("\u2551"))}
+${import_picocolors9.default.bold(import_picocolors9.default.cyan("  \u2551"))}  ${import_picocolors9.default.dim("https://qaskills.sh")}                  ${import_picocolors9.default.bold(import_picocolors9.default.cyan("\u2551"))}
+${import_picocolors9.default.bold(import_picocolors9.default.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"))}
+`;
+program.name("qaskills").description("QA Skills Directory for AI Coding Agents").version("0.1.0").addHelpText("before", banner).addCommand(addCommand).addCommand(searchCommand).addCommand(initCommand).addCommand(listCommand).addCommand(removeCommand).addCommand(updateCommand).addCommand(infoCommand).addCommand(publishCommand);
+program.parse();

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@qaskills/cli",
+  "version": "0.1.0",
+  "description": "CLI tool for QA Skills Directory — install, search, and manage QA testing skills for AI coding agents",
+  "bin": {
+    "qaskills": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "keywords": [
+    "qa",
+    "testing",
+    "ai-agents",
+    "claude-code",
+    "cursor",
+    "skills",
+    "cli"
+  ],
+  "author": "Pramod Dutta <TheTestingAcademy>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PramodDutta/qaskills"
+  },
+  "homepage": "https://qaskills.sh",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.8.0",
+    "commander": "^12.1.0",
+    "picocolors": "^1.1.0",
+    "@qaskills/shared": "0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}