@wcag-audit/cli 1.0.0-alpha.11

package/src/commands/doctor.js

@@ -0,0 +1,105 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { readGlobalConfig } from "../config/global.js";
+import { validateLicense } from "../license/validate.js";
+import { detectFramework } from "../discovery/registry.js";
+
+const CLI_VERSION = "1.0.0-alpha.11";
+
+export async function runDoctor({ cwd = process.cwd(), log = console.log } = {}) {
+  const checks = [];
+
+  // ── License ──────────────────────────────────────────────────────
+  const globalCfg = await readGlobalConfig();
+  if (!globalCfg.licenseKey) {
+    checks.push({
+      name: "license",
+      status: "fail",
+      message: "No license key found in ~/.wcagauditrc. Run `npx wcag-audit init` to set one.",
+    });
+  } else {
+    const license = await validateLicense(globalCfg.licenseKey, {
+      machineId: randomUUID(),
+      source: "cli",
+      version: CLI_VERSION,
+    });
+    if (!license.valid) {
+      checks.push({
+        name: "license",
+        status: "fail",
+        message: `License validation failed: ${license.error}`,
+      });
+    } else {
+      const credits = license.creditsRemaining?.total ?? "unlimited";
+      checks.push({
+        name: "license",
+        status: "pass",
+        message: `${license.tier} plan, ${credits} credits remaining`,
+      });
+    }
+  }
+
+  // ── AI key (optional) ───────────────────────────────────────────
+  if (globalCfg.ai?.enabled) {
+    if (!globalCfg.ai.apiKey) {
+      checks.push({
+        name: "ai-key",
+        status: "fail",
+        message: "AI review is enabled but no API key is configured. Re-run `wcag-audit init`.",
+      });
+    } else {
+      checks.push({
+        name: "ai-key",
+        status: "pass",
+        message: `${globalCfg.ai.provider} key present`,
+      });
+    }
+  }
+
+  // ── Framework ────────────────────────────────────────────────────
+  const det = await detectFramework(cwd);
+  if (!det) {
+    checks.push({
+      name: "framework",
+      status: "fail",
+      message:
+        "Could not detect a supported framework. Supported: Next.js, Vite+React Router, SvelteKit, Remix, Astro. Use --url or --routes for deployed sites / custom setups.",
+    });
+  } else {
+    checks.push({
+      name: "framework",
+      status: "pass",
+      message: `${det.framework} detected (${det.strategy})`,
+    });
+  }
+
+  // ── Dev script ───────────────────────────────────────────────────
+  try {
+    const pkg = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
+    const hasDev = pkg.scripts && (pkg.scripts.dev || pkg.scripts.start);
+    checks.push({
+      name: "dev-script",
+      status: hasDev ? "pass" : "fail",
+      message: hasDev
+        ? `\`${pkg.scripts.dev ? "npm run dev" : "npm run start"}\` will be used to start the dev server`
+        : "No `dev` or `start` script in package.json. Add one or set devServer.command in .wcagauditrc.",
+    });
+  } catch {
+    // package.json doesn't exist — already failed on framework check
+  }
+
+  // ── Print results ────────────────────────────────────────────────
+  log("");
+  log("wcag-audit doctor");
+  log("─────────────────────────────");
+  for (const c of checks) {
+    const icon = c.status === "pass" ? "✓" : "✗";
+    log(`${icon} ${c.name.padEnd(14)} ${c.message}`);
+  }
+  log("");
+  const failing = checks.filter((c) => c.status === "fail");
+  const ok = failing.length === 0;
+  log(ok ? "All checks passed." : `${failing.length} check(s) failed. Fix these before running scan.`);
+  return { ok, checks };
+}

package/src/commands/doctor.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { runDoctor } from "./doctor.js";
+
+let tmpHome;
+let projDir;
+
+beforeEach(async () => {
+  tmpHome = await mkdtemp(join(tmpdir(), "wcagdoc-home-"));
+  projDir = await mkdtemp(join(tmpdir(), "wcagdoc-proj-"));
+  process.env.HOME = tmpHome;
+  global.fetch = vi.fn();
+});
+
+afterEach(async () => {
+  await rm(tmpHome, { recursive: true, force: true });
+  await rm(projDir, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+describe("runDoctor", () => {
+  it("reports missing license when no global config exists", async () => {
+    const logs = [];
+    const result = await runDoctor({ cwd: projDir, log: (m) => logs.push(m) });
+    expect(result.ok).toBe(false);
+    expect(result.checks.find((c) => c.name === "license")?.status).toBe("fail");
+    const joined = logs.join("\n");
+    expect(joined).toMatch(/✗ license/);
+    expect(joined).toMatch(/wcag-audit init/);
+  });
+
+  it("marks license pass when config + validation succeed", async () => {
+    await writeFile(
+      join(tmpHome, ".wcagauditrc"),
+      JSON.stringify({
+        licenseKey: "WCAG-TEST-AAAA-BBBB-CCCC",
+        ai: { enabled: false, provider: "anthropic", apiKey: null },
+      }),
+      "utf8",
+    );
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ valid: true, tier: "pro", creditsRemaining: { total: 100 } }),
+    });
+    const result = await runDoctor({ cwd: projDir, log: () => {} });
+    expect(result.checks.find((c) => c.name === "license")?.status).toBe("pass");
+  });
+
+  it("reports missing framework when cwd is not a Next.js project", async () => {
+    await writeFile(
+      join(tmpHome, ".wcagauditrc"),
+      JSON.stringify({ licenseKey: "WCAG-TEST-AAAA-BBBB-CCCC", ai: { enabled: false } }),
+      "utf8",
+    );
+    global.fetch.mockResolvedValue({ ok: true, json: async () => ({ valid: true, tier: "pro" }) });
+    const result = await runDoctor({ cwd: projDir, log: () => {} });
+    expect(result.checks.find((c) => c.name === "framework")?.status).toBe("fail");
+  });
+
+  it("reports framework pass when cwd is a Next.js app", async () => {
+    await writeFile(
+      join(tmpHome, ".wcagauditrc"),
+      JSON.stringify({ licenseKey: "WCAG-TEST-AAAA-BBBB-CCCC", ai: { enabled: false } }),
+      "utf8",
+    );
+    await writeFile(
+      join(projDir, "package.json"),
+      JSON.stringify({ dependencies: { next: "15.0.0" }, scripts: { dev: "next dev" } }),
+      "utf8",
+    );
+    const { mkdir } = await import("fs/promises");
+    await mkdir(join(projDir, "app"), { recursive: true });
+    await writeFile(join(projDir, "app", "page.tsx"), "// test", "utf8");
+    global.fetch.mockResolvedValue({ ok: true, json: async () => ({ valid: true, tier: "pro" }) });
+    const result = await runDoctor({ cwd: projDir, log: () => {} });
+    expect(result.checks.find((c) => c.name === "framework")?.status).toBe("pass");
+    expect(result.checks.find((c) => c.name === "dev-script")?.status).toBe("pass");
+  });
+});

package/src/commands/init.js

@@ -0,0 +1,162 @@
+import enquirer from "enquirer";
+import { randomUUID } from "crypto";
+import { validateLicense } from "../license/validate.js";
+import { requestFreeLicense } from "../license/request-free.js";
+import { writeGlobalConfig } from "../config/global.js";
+
+const CLI_VERSION = "1.0.0-alpha.11";
+
+// runInit can be called two ways:
+//   1. Interactive (no answers) — uses enquirer to prompt
+//   2. Non-interactive (answers provided) — used by tests and CI
+export async function runInit({ answers, log = console.log } = {}) {
+  log("");
+  log("Welcome to WCAG Audit CLI");
+  log("");
+
+  const resolved = answers || (await promptUser({ log }));
+
+  // 1. Validate license
+  const machineId = randomUUID();
+  const license = await validateLicense(resolved.licenseKey, {
+    machineId,
+    source: "cli",
+    version: CLI_VERSION,
+  });
+
+  if (!license.valid) {
+    log(`✗ License check failed: ${license.error}`);
+    return { ok: false, error: license.error };
+  }
+
+  const credits = license.creditsRemaining?.total ?? "unlimited";
+  log(`✓ License valid (${license.tier} plan, ${credits} credits remaining)`);
+
+  // 2. Write config
+  const aiConfig = resolved.enableAi
+    ? {
+        enabled: true,
+        provider: resolved.aiProvider,
+        apiKey: resolved.aiApiKey,
+        model: defaultModelFor(resolved.aiProvider),
+        groups: resolved.aiGroups || ["visual", "structure", "language"],
+      }
+    : {
+        enabled: false,
+        provider: "anthropic",
+        apiKey: null,
+        model: null,
+        groups: [],
+      };
+
+  await writeGlobalConfig({
+    licenseKey: resolved.licenseKey,
+    ai: aiConfig,
+  });
+
+  log("✓ Config saved to ~/.wcagauditrc (chmod 600)");
+  log("  Run `npx wcag-audit scan` in your project directory to start.");
+  log("");
+
+  return { ok: true, tier: license.tier };
+}
+
+function defaultModelFor(provider) {
+  return {
+    anthropic: "claude-sonnet-4-6",
+    openai: "gpt-4.1-mini",
+    google: "gemini-2.5-flash",
+  }[provider] || "claude-sonnet-4-6";
+}
+
+async function promptUser({ log = console.log } = {}) {
+  // Step 1: Has a key? Or request free?
+  const { hasKey } = await enquirer.prompt([
+    {
+      type: "confirm",
+      name: "hasKey",
+      message: "Do you already have a license key?",
+      initial: true,
+    },
+  ]);
+
+  if (!hasKey) {
+    // Free-tier flow: ask for email, request a free key, wait for them
+    // to paste it from their inbox.
+    const { email } = await enquirer.prompt([
+      {
+        type: "input",
+        name: "email",
+        message: "Enter your email for a free license (1 audit/day):",
+        validate: (v) => (/@.+\./.test(v) ? true : "Enter a valid email"),
+      },
+    ]);
+    log("");
+    log(`Requesting free license for ${email}...`);
+    const machineId = randomUUID();
+    const result = await requestFreeLicense({ email, machineId });
+    if (!result.ok) {
+      log(`✗ ${result.error}`);
+      log("  You can try again or skip and use --help to paste a key later.");
+      throw new Error(result.error);
+    }
+    log(`✓ ${result.message}`);
+    log("");
+  }
+
+  // Step 2: Paste the key (works for both free and paid)
+  const answers = await enquirer.prompt([
+    {
+      type: "input",
+      name: "licenseKey",
+      message: "Paste your WCAG Audit license key:",
+      validate(value) {
+        if (!/^WCAG-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/i.test(value?.trim())) {
+          return "Expected format: WCAG-XXXX-XXXX-XXXX-XXXX";
+        }
+        return true;
+      },
+      result: (v) => v.trim().toUpperCase(),
+    },
+    {
+      type: "confirm",
+      name: "enableAi",
+      message: "Enable AI vision review? (uses your own LLM API key)",
+      initial: true,
+    },
+  ]);
+
+  if (!answers.enableAi) return answers;
+
+  const aiAnswers = await enquirer.prompt([
+    {
+      type: "select",
+      name: "aiProvider",
+      message: "Choose AI provider:",
+      choices: [
+        { name: "anthropic", message: "Anthropic Claude (recommended)" },
+        { name: "openai", message: "OpenAI GPT" },
+        { name: "google", message: "Google Gemini" },
+      ],
+    },
+    {
+      type: "password",
+      name: "aiApiKey",
+      message: "Paste your API key:",
+      validate: (v) => (v && v.length > 10 ? true : "API key seems too short"),
+    },
+    {
+      type: "multiselect",
+      name: "aiGroups",
+      message: "Which AI review groups to enable?",
+      choices: [
+        { name: "visual", message: "Visual quality (color, layout, hierarchy)" },
+        { name: "structure", message: "Structure & navigation" },
+        { name: "language", message: "Reading & language" },
+      ],
+      initial: [0, 1, 2],
+    },
+  ]);
+
+  return { ...answers, ...aiAnswers };
+}

package/src/commands/init.test.js

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtemp, rm, readFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { runInit } from "./init.js";
+
+let tmpHome;
+
+beforeEach(async () => {
+  tmpHome = await mkdtemp(join(tmpdir(), "wcaginit-"));
+  process.env.HOME = tmpHome;
+  global.fetch = vi.fn();
+});
+
+afterEach(async () => {
+  await rm(tmpHome, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+describe("runInit", () => {
+  it("writes licenseKey + AI config when validation passes", async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ valid: true, tier: "pro", creditsRemaining: { total: 100 } }),
+    });
+    const logs = [];
+    const result = await runInit({
+      answers: {
+        licenseKey: "WCAG-TEST-AAAA-BBBB-CCCC",
+        enableAi: true,
+        aiProvider: "anthropic",
+        aiApiKey: "sk-ant-x",
+        aiGroups: ["visual", "structure"],
+      },
+      log: (msg) => logs.push(msg),
+    });
+    expect(result.ok).toBe(true);
+    const raw = await readFile(join(tmpHome, ".wcagauditrc"), "utf8");
+    const cfg = JSON.parse(raw);
+    expect(cfg.licenseKey).toBe("WCAG-TEST-AAAA-BBBB-CCCC");
+    expect(cfg.ai.enabled).toBe(true);
+    expect(cfg.ai.provider).toBe("anthropic");
+    expect(cfg.ai.apiKey).toBe("sk-ant-x");
+    expect(cfg.ai.groups).toEqual(["visual", "structure"]);
+    expect(logs.join("\n")).toMatch(/Config saved/);
+  });
+
+  it("rejects and exits when license validation fails", async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: false,
+      status: 403,
+      json: async () => ({ valid: false, error: "License revoked" }),
+    });
+    const result = await runInit({
+      answers: {
+        licenseKey: "WCAG-TEST-AAAA-BBBB-CCCC",
+        enableAi: false,
+      },
+      log: () => {},
+    });
+    expect(result.ok).toBe(false);
+    expect(result.error).toMatch(/revoked/i);
+  });
+
+  it("does not write AI config when enableAi is false", async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ valid: true, tier: "pro", creditsRemaining: { total: 100 } }),
+    });
+    const result = await runInit({
+      answers: {
+        licenseKey: "WCAG-TEST-AAAA-BBBB-CCCC",
+        enableAi: false,
+      },
+      log: () => {},
+    });
+    expect(result.ok).toBe(true);
+    const raw = await readFile(join(tmpHome, ".wcagauditrc"), "utf8");
+    const cfg = JSON.parse(raw);
+    expect(cfg.ai.enabled).toBe(false);
+    expect(cfg.ai.apiKey).toBe(null);
+  });
+});