asc-doctor 1.0.0

package/dist/index.js

@@ -0,0 +1,2014 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+import fs3 from "fs";
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+var CONFIG_FILE_NAMES = [".ascdocrc.json", ".ascdocrc", "ascdoc.config.json"];
+function findConfigFile(cwd) {
+  for (const name of CONFIG_FILE_NAMES) {
+    const filePath = path.join(cwd, name);
+    if (fs.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function loadConfigFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function loadEnvConfig() {
+  const config = {};
+  if (process.env.ASC_KEY_ID) config.keyId = process.env.ASC_KEY_ID;
+  if (process.env.ASC_ISSUER_ID) config.issuerId = process.env.ASC_ISSUER_ID;
+  if (process.env.ASC_KEY_PATH) config.keyPath = process.env.ASC_KEY_PATH;
+  if (process.env.ASC_APP_ID) config.appId = process.env.ASC_APP_ID;
+  if (process.env.ASC_MIN_SCORE) config.minScore = parseInt(process.env.ASC_MIN_SCORE, 10);
+  return config;
+}
+function resolveConfig(cliOptions) {
+  const defaults = {
+    keyId: "",
+    issuerId: "",
+    keyPath: "",
+    appId: void 0,
+    minScore: 0,
+    skip: [],
+    only: [],
+    format: "terminal",
+    output: void 0,
+    ci: false,
+    demo: false
+  };
+  const configFilePath = findConfigFile(process.cwd());
+  const fileConfig = configFilePath ? loadConfigFile(configFilePath) : {};
+  const envConfig = loadEnvConfig();
+  const merged = {
+    ...defaults,
+    ...fileConfig,
+    ...envConfig,
+    ...stripUndefined(cliOptions)
+  };
+  return merged;
+}
+function stripUndefined(obj) {
+  const result = {};
+  for (const key in obj) {
+    if (obj[key] !== void 0) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function validateConfig(config) {
+  if (config.demo) return [];
+  const errors = [];
+  if (!config.keyId) {
+    errors.push("Missing --key-id (or ASC_KEY_ID env variable)");
+  }
+  if (!config.issuerId) {
+    errors.push("Missing --issuer-id (or ASC_ISSUER_ID env variable)");
+  }
+  if (!config.keyPath) {
+    errors.push("Missing --key (or ASC_KEY_PATH env variable)");
+  } else if (!fs.existsSync(config.keyPath)) {
+    errors.push(`Key file not found: ${config.keyPath}`);
+  }
+  return errors;
+}
+
+// src/auth.ts
+import fs2 from "fs";
+import * as jose from "jose";
+var cachedToken = null;
+var tokenExpiry = 0;
+async function generateToken(credentials) {
+  const now = Math.floor(Date.now() / 1e3);
+  if (cachedToken && tokenExpiry > now + 60) {
+    return cachedToken;
+  }
+  const privateKeyPem = fs2.readFileSync(credentials.keyPath, "utf-8");
+  const privateKey = await jose.importPKCS8(privateKeyPem, "ES256");
+  const jwt = await new jose.SignJWT({}).setProtectedHeader({
+    alg: "ES256",
+    kid: credentials.keyId,
+    typ: "JWT"
+  }).setIssuer(credentials.issuerId).setIssuedAt(now).setExpirationTime(now + 1200).setAudience("appstoreconnect-v1").sign(privateKey);
+  cachedToken = jwt;
+  tokenExpiry = now + 1200;
+  return jwt;
+}
+
+// src/api/client.ts
+var BASE_URL = "https://api.appstoreconnect.apple.com";
+var MAX_RETRIES = 3;
+var RATE_LIMIT_DELAY = 1100;
+var ASCAPIError = class extends Error {
+  constructor(status, errors) {
+    const message = errors.map((e) => `[${e.status}] ${e.title}: ${e.detail}`).join("\n");
+    super(message);
+    this.status = status;
+    this.errors = errors;
+    this.name = "ASCAPIError";
+  }
+  status;
+  errors;
+};
+var lastRequestTime = 0;
+async function throttle() {
+  const now = Date.now();
+  const elapsed = now - lastRequestTime;
+  if (elapsed < RATE_LIMIT_DELAY && lastRequestTime > 0) {
+    await new Promise((resolve) => setTimeout(resolve, RATE_LIMIT_DELAY - elapsed));
+  }
+  lastRequestTime = Date.now();
+}
+var APIClient = class {
+  credentials;
+  constructor(credentials) {
+    this.credentials = credentials;
+  }
+  async request(path2, params) {
+    await throttle();
+    const token = await generateToken(this.credentials);
+    const url = new URL(path2, BASE_URL);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const response = await fetch(url.toString(), {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json"
+          }
+        });
+        if (response.status === 429) {
+          const retryAfter = parseInt(response.headers.get("Retry-After") || "5", 10);
+          await new Promise((resolve) => setTimeout(resolve, retryAfter * 1e3));
+          continue;
+        }
+        if (!response.ok) {
+          const body = await response.json();
+          throw new ASCAPIError(response.status, body.errors || []);
+        }
+        return await response.json();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof ASCAPIError && error.status !== 429 && error.status !== 500) {
+          throw error;
+        }
+        if (attempt < MAX_RETRIES - 1) {
+          await new Promise((resolve) => setTimeout(resolve, 1e3 * (attempt + 1)));
+        }
+      }
+    }
+    throw lastError || new Error("Max retries exceeded");
+  }
+  async paginate(path2, params) {
+    const allData = [];
+    let nextUrl = void 0;
+    const limit = "200";
+    const initialParams = { ...params, "limit": limit };
+    const firstResponse = await this.request(path2, initialParams);
+    allData.push(...Array.isArray(firstResponse.data) ? firstResponse.data : [firstResponse.data]);
+    nextUrl = firstResponse.links?.next;
+    while (nextUrl) {
+      await throttle();
+      const token = await generateToken(this.credentials);
+      const response = await fetch(nextUrl, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        break;
+      }
+      const body = await response.json();
+      if (Array.isArray(body.data)) {
+        allData.push(...body.data);
+      }
+      nextUrl = body.links?.next;
+    }
+    return allData;
+  }
+};
+
+// src/api/fetcher.ts
+async function fetchAppData(client, appId) {
+  const app = await resolveApp(client, appId);
+  const version = await getLatestVersion(client, app.id);
+  const [
+    versionLocalizations,
+    appInfoResult,
+    screenshotSets,
+    reviewDetail
+  ] = await Promise.all([
+    getVersionLocalizations(client, version.id),
+    getAppInfo(client, app.id),
+    getScreenshotSets(client, version.id),
+    getReviewDetail(client, version.id)
+  ]);
+  const { appInfo, appInfoLocalizations, ageRatingDeclaration } = appInfoResult;
+  const [subscriptionData, iapData, territories] = await Promise.all([
+    getSubscriptionData(client, app.id),
+    getIAPData(client, app.id),
+    getTerritories(client, app.id)
+  ]);
+  return {
+    app,
+    version,
+    versionLocalizations,
+    appInfo,
+    appInfoLocalizations,
+    ageRatingDeclaration,
+    screenshotSets,
+    ...subscriptionData,
+    inAppPurchases: iapData,
+    reviewDetail,
+    availableTerritories: territories
+  };
+}
+async function resolveApp(client, appId) {
+  if (appId) {
+    const response = await client.request(`/v1/apps/${appId}`);
+    return response.data;
+  }
+  const apps = await client.paginate("/v1/apps");
+  if (apps.length === 0) {
+    throw new Error("No apps found in your App Store Connect account.");
+  }
+  if (apps.length === 1) {
+    return apps[0];
+  }
+  const appList = apps.map((a) => `  \u2022 ${a.attributes.name} (${a.attributes.bundleId}) \u2192 --app-id ${a.id}`).join("\n");
+  throw new Error(
+    `Multiple apps found. Please specify --app-id:
+
+${appList}`
+  );
+}
+async function getLatestVersion(client, appId) {
+  const versions = await client.paginate(
+    `/v1/apps/${appId}/appStoreVersions`,
+    {
+      "filter[platform]": "IOS",
+      "sort": "-createdDate",
+      "limit": "5"
+    }
+  );
+  if (versions.length === 0) {
+    throw new Error("No App Store versions found for this app.");
+  }
+  const editableStates = [
+    "PREPARE_FOR_SUBMISSION",
+    "DEVELOPER_REJECTED",
+    "REJECTED",
+    "METADATA_REJECTED",
+    "INVALID_BINARY"
+  ];
+  const editable = versions.find((v) => editableStates.includes(v.attributes.appStoreState));
+  return editable || versions[0];
+}
+async function getVersionLocalizations(client, versionId) {
+  return client.paginate(
+    `/v1/appStoreVersions/${versionId}/appStoreVersionLocalizations`
+  );
+}
+async function getAppInfo(client, appId) {
+  const appInfos = await client.paginate(`/v1/apps/${appId}/appInfos`);
+  if (appInfos.length === 0) {
+    throw new Error("No app info found.");
+  }
+  const appInfo = appInfos[0];
+  const [localizations, ageRating] = await Promise.all([
+    client.paginate(
+      `/v1/appInfos/${appInfo.id}/appInfoLocalizations`
+    ),
+    getAgeRatingDeclaration(client, appInfo.id)
+  ]);
+  return {
+    appInfo,
+    appInfoLocalizations: localizations,
+    ageRatingDeclaration: ageRating
+  };
+}
+async function getAgeRatingDeclaration(client, appInfoId) {
+  try {
+    const response = await client.request(
+      `/v1/appInfos/${appInfoId}/ageRatingDeclaration`
+    );
+    return response.data;
+  } catch {
+    return null;
+  }
+}
+async function getScreenshotSets(client, versionId) {
+  const localizations = await client.paginate(
+    `/v1/appStoreVersions/${versionId}/appStoreVersionLocalizations`
+  );
+  const allSets = [];
+  for (const loc of localizations) {
+    const sets = await client.paginate(
+      `/v1/appStoreVersionLocalizations/${loc.id}/appScreenshotSets`
+    );
+    for (const set of sets) {
+      const screenshots = await client.paginate(
+        `/v1/appScreenshotSets/${set.id}/appScreenshots`
+      );
+      allSets.push({
+        ...set,
+        screenshotCount: screenshots.length,
+        locale: loc.attributes.locale
+      });
+    }
+  }
+  return allSets;
+}
+async function getReviewDetail(client, versionId) {
+  try {
+    const response = await client.request(
+      `/v1/appStoreVersions/${versionId}/appStoreReviewDetail`
+    );
+    return response.data;
+  } catch {
+    return null;
+  }
+}
+async function getSubscriptionData(client, appId) {
+  try {
+    const groups = await client.paginate(
+      `/v1/apps/${appId}/subscriptionGroups`
+    );
+    const subscriptions = [];
+    const groupLocalizations = [];
+    for (const group of groups) {
+      const subs = await client.paginate(
+        `/v1/subscriptionGroups/${group.id}/subscriptions`
+      );
+      for (const sub of subs) {
+        const locs = await client.paginate(
+          `/v1/subscriptions/${sub.id}/subscriptionLocalizations`
+        );
+        subscriptions.push({ ...sub, localizations: locs });
+      }
+      const gLocs = await client.paginate(
+        `/v1/subscriptionGroups/${group.id}/subscriptionGroupLocalizations`
+      );
+      groupLocalizations.push({ groupId: group.id, localizations: gLocs });
+    }
+    return {
+      subscriptionGroups: groups,
+      subscriptions,
+      subscriptionGroupLocalizations: groupLocalizations
+    };
+  } catch {
+    return {
+      subscriptionGroups: [],
+      subscriptions: [],
+      subscriptionGroupLocalizations: []
+    };
+  }
+}
+async function getIAPData(client, appId) {
+  try {
+    const iaps = await client.paginate(
+      `/v2/apps/${appId}/inAppPurchasesV2`
+    );
+    const enriched = [];
+    for (const iap of iaps) {
+      const locs = await client.paginate(
+        `/v2/inAppPurchases/${iap.id}/inAppPurchaseLocalizations`
+      );
+      enriched.push({ ...iap, localizations: locs });
+    }
+    return enriched;
+  } catch {
+    return [];
+  }
+}
+async function getTerritories(client, appId) {
+  try {
+    return await client.paginate(
+      `/v1/apps/${appId}/availableTerritories`
+    );
+  } catch {
+    return [];
+  }
+}
+
+// src/auditors/localization.ts
+var PLACEHOLDER_PATTERNS = [
+  /lorem\s+ipsum/i,
+  /\bTODO\b/,
+  /\bTBD\b/,
+  /\bFIXME\b/,
+  /\[PLACEHOLDER\]/i,
+  /\bXXX\b/,
+  /\bsample\s+text\b/i,
+  /\bdummy\b/i,
+  /\btest\s+description\b/i,
+  /\bcoming\s+soon\b/i
+];
+function auditLocalization(data) {
+  const start = Date.now();
+  const findings = [];
+  const primaryLocale = data.app.attributes.primaryLocale;
+  for (const loc of data.versionLocalizations) {
+    const locale = loc.attributes.locale;
+    const attrs = loc.attributes;
+    if (!attrs.description || attrs.description.trim().length === 0) {
+      findings.push({
+        id: "LOC-001",
+        module: "localization",
+        severity: "critical",
+        title: `Missing description for locale \`${locale}\``,
+        message: `The App Store description is empty for the ${locale} localization. This is a required field for submission.`,
+        locale,
+        remedy: `Add a compelling description for ${locale} in App Store Connect > App Store > Version Information.`
+      });
+    }
+    if (!attrs.keywords || attrs.keywords.trim().length === 0) {
+      findings.push({
+        id: "LOC-002",
+        module: "localization",
+        severity: "warning",
+        title: `Missing keywords for locale \`${locale}\``,
+        message: `Keywords field is empty for ${locale}. This is a missed ASO (App Store Optimization) opportunity.`,
+        locale,
+        remedy: `Add comma-separated keywords (max 100 chars) for ${locale} to improve search visibility.`
+      });
+    }
+    if (!attrs.promotionalText || attrs.promotionalText.trim().length === 0) {
+      findings.push({
+        id: "LOC-003",
+        module: "localization",
+        severity: "info",
+        title: `Missing promotional text for locale \`${locale}\``,
+        message: `Promotional text is empty for ${locale}. This field can be updated without app review.`,
+        locale,
+        remedy: `Add promotional text for ${locale}. This is shown at the top of the description and can be updated anytime.`
+      });
+    }
+    if (attrs.description) {
+      for (const pattern of PLACEHOLDER_PATTERNS) {
+        if (pattern.test(attrs.description)) {
+          findings.push({
+            id: "LOC-004",
+            module: "localization",
+            severity: "critical",
+            title: `Placeholder text detected in \`${locale}\` description`,
+            message: `The description for ${locale} contains placeholder text matching "${pattern.source}". This will likely cause rejection.`,
+            locale,
+            remedy: `Replace placeholder text in the ${locale} description with real content before submission.`
+          });
+          break;
+        }
+      }
+    }
+    if (attrs.description && attrs.description.trim().length > 0 && attrs.description.trim().length < 100) {
+      findings.push({
+        id: "LOC-005",
+        module: "localization",
+        severity: "warning",
+        title: `Description too short for locale \`${locale}\``,
+        message: `The description for ${locale} is only ${attrs.description.trim().length} characters. Consider expanding it for better ASO.`,
+        locale,
+        remedy: `Expand the ${locale} description to at least 100 characters with feature highlights, benefits, and relevant keywords.`
+      });
+    }
+    if (attrs.keywords) {
+      for (const pattern of PLACEHOLDER_PATTERNS) {
+        if (pattern.test(attrs.keywords)) {
+          findings.push({
+            id: "LOC-006",
+            module: "localization",
+            severity: "critical",
+            title: `Placeholder text in \`${locale}\` keywords`,
+            message: `Keywords for ${locale} contain placeholder text matching "${pattern.source}".`,
+            locale,
+            remedy: `Replace placeholder keywords with real, relevant search terms for ${locale}.`
+          });
+          break;
+        }
+      }
+    }
+  }
+  const hasPrimaryLocale = data.versionLocalizations.some(
+    (l) => l.attributes.locale === primaryLocale
+  );
+  if (!hasPrimaryLocale) {
+    findings.push({
+      id: "LOC-007",
+      module: "localization",
+      severity: "critical",
+      title: `Primary locale \`${primaryLocale}\` missing version localization`,
+      message: `Your app's primary locale (${primaryLocale}) has no version localization. This is required for submission.`,
+      locale: primaryLocale,
+      remedy: `Add a version localization for your primary locale (${primaryLocale}) in App Store Connect.`
+    });
+  }
+  const versionLocales = new Set(data.versionLocalizations.map((l) => l.attributes.locale));
+  const infoLocales = new Set(data.appInfoLocalizations.map((l) => l.attributes.locale));
+  for (const infoLocale of infoLocales) {
+    if (!versionLocales.has(infoLocale)) {
+      findings.push({
+        id: "LOC-008",
+        module: "localization",
+        severity: "high",
+        title: `App info locale \`${infoLocale}\` missing version metadata`,
+        message: `App info localization exists for ${infoLocale} but there's no corresponding version localization (description, keywords, etc.).`,
+        locale: infoLocale,
+        remedy: `Add version metadata (description, keywords) for ${infoLocale} or remove the app info localization if not needed.`
+      });
+    }
+  }
+  return {
+    module: "localization",
+    label: "Localization",
+    icon: "\u{1F30D}",
+    findings,
+    duration: Date.now() - start
+  };
+}
+
+// src/auditors/screenshots.ts
+var REQUIRED_IPHONE_TYPES = [
+  "APP_IPHONE_67",
+  // 6.7" (iPhone 15 Pro Max, 16 Plus)
+  "APP_IPHONE_69"
+  // 6.9" (iPhone 16 Pro Max) — newest
+];
+var DEVICE_TYPE_LABELS = {
+  "APP_IPHONE_35": 'iPhone 3.5"',
+  "APP_IPHONE_40": 'iPhone 4.0"',
+  "APP_IPHONE_47": 'iPhone 4.7"',
+  "APP_IPHONE_55": 'iPhone 5.5"',
+  "APP_IPHONE_58": 'iPhone 5.8"',
+  "APP_IPHONE_61": 'iPhone 6.1"',
+  "APP_IPHONE_65": 'iPhone 6.5"',
+  "APP_IPHONE_67": 'iPhone 6.7"',
+  "APP_IPHONE_69": 'iPhone 6.9"',
+  "APP_IPAD_97": 'iPad 9.7"',
+  "APP_IPAD_105": 'iPad 10.5"',
+  "APP_IPAD_PRO_3GEN_11": 'iPad Pro 11"',
+  "APP_IPAD_PRO_3GEN_129": 'iPad Pro 12.9"',
+  "APP_IPAD_PRO_129": 'iPad Pro 12.9"',
+  "APP_IPAD_13": 'iPad 13"',
+  "APP_APPLE_TV": "Apple TV",
+  "APP_WATCH_ULTRA": "Apple Watch Ultra",
+  "APP_WATCH_SERIES_7": "Apple Watch Series 7+",
+  "APP_WATCH_SERIES_4": "Apple Watch Series 4-6",
+  "APP_DESKTOP": "Mac Desktop"
+};
+function auditScreenshots(data) {
+  const start = Date.now();
+  const findings = [];
+  const platform = data.version.attributes.platform;
+  const setsByLocale = /* @__PURE__ */ new Map();
+  for (const set of data.screenshotSets) {
+    const locale = set.locale;
+    if (!setsByLocale.has(locale)) {
+      setsByLocale.set(locale, []);
+    }
+    setsByLocale.get(locale).push(set);
+  }
+  for (const loc of data.versionLocalizations) {
+    const locale = loc.attributes.locale;
+    const sets = setsByLocale.get(locale);
+    if (!sets || sets.length === 0) {
+      findings.push({
+        id: "SCR-001",
+        module: "screenshots",
+        severity: "critical",
+        title: `No screenshots for locale \`${locale}\``,
+        message: `The ${locale} localization has no screenshot sets. At least one set with screenshots is required for submission.`,
+        locale,
+        remedy: `Upload screenshots for ${locale} in App Store Connect > App Store > Version > Media.`
+      });
+      continue;
+    }
+    const deviceTypes = sets.map((s) => s.attributes.screenshotDisplayType);
+    if (platform === "IOS") {
+      const hasRequiredIPhone = REQUIRED_IPHONE_TYPES.some((t) => deviceTypes.includes(t));
+      if (!hasRequiredIPhone) {
+        findings.push({
+          id: "SCR-002",
+          module: "screenshots",
+          severity: "critical",
+          title: `Missing required iPhone screenshots for \`${locale}\``,
+          message: `No 6.7" or 6.9" iPhone screenshots found for ${locale}. Apple requires screenshots for the largest iPhone display.`,
+          locale,
+          remedy: `Upload 6.9" (1320\xD72868) or 6.7" (1290\xD72796) iPhone screenshots for ${locale}.`
+        });
+      }
+    }
+    for (const set of sets) {
+      if (set.screenshotCount === 0) {
+        const deviceLabel = DEVICE_TYPE_LABELS[set.attributes.screenshotDisplayType] || set.attributes.screenshotDisplayType;
+        findings.push({
+          id: "SCR-003",
+          module: "screenshots",
+          severity: "high",
+          title: `Empty screenshot set for ${deviceLabel} in \`${locale}\``,
+          message: `A screenshot set exists for ${deviceLabel} (${locale}) but contains 0 screenshots. Either upload screenshots or remove the empty set.`,
+          locale,
+          remedy: `Upload screenshots to the ${deviceLabel} set for ${locale}, or delete the empty set.`
+        });
+      }
+    }
+    for (const set of sets) {
+      if (set.screenshotCount > 0 && set.screenshotCount < 3) {
+        const deviceLabel = DEVICE_TYPE_LABELS[set.attributes.screenshotDisplayType] || set.attributes.screenshotDisplayType;
+        findings.push({
+          id: "SCR-004",
+          module: "screenshots",
+          severity: "warning",
+          title: `Few screenshots for ${deviceLabel} in \`${locale}\``,
+          message: `Only ${set.screenshotCount} screenshot(s) for ${deviceLabel} (${locale}). Apple allows up to 10. More screenshots improve conversion.`,
+          locale,
+          remedy: `Consider adding more screenshots (recommended: 5-8) for ${deviceLabel} in ${locale}.`
+        });
+      }
+    }
+  }
+  const primaryLocale = data.app.attributes.primaryLocale;
+  if (!setsByLocale.has(primaryLocale) || setsByLocale.get(primaryLocale).length === 0) {
+    const alreadyCaught = findings.some(
+      (f) => f.id === "SCR-001" && f.locale === primaryLocale
+    );
+    if (!alreadyCaught) {
+      findings.push({
+        id: "SCR-005",
+        module: "screenshots",
+        severity: "critical",
+        title: `Primary locale \`${primaryLocale}\` has no screenshots`,
+        message: `Your primary locale (${primaryLocale}) is missing screenshots. This is required for submission.`,
+        locale: primaryLocale,
+        remedy: `Upload screenshots for your primary locale (${primaryLocale}) before submitting.`
+      });
+    }
+  }
+  return {
+    module: "screenshots",
+    label: "Screenshots",
+    icon: "\u{1F4F1}",
+    findings,
+    duration: Date.now() - start
+  };
+}
+
+// src/auditors/age-rating.ts
+var NONE_VALUE = "NONE";
+function auditAgeRating(data) {
+  const start = Date.now();
+  const findings = [];
+  if (!data.ageRatingDeclaration) {
+    findings.push({
+      id: "AGE-001",
+      module: "age-rating",
+      severity: "high",
+      title: "Age rating declaration not found",
+      message: "Could not retrieve the age rating declaration. This may indicate it has not been configured.",
+      remedy: "Go to App Store Connect > App Information > Age Rating and complete the questionnaire."
+    });
+    return {
+      module: "age-rating",
+      label: "Age Rating",
+      icon: "\u{1F51E}",
+      findings,
+      duration: Date.now() - start
+    };
+  }
+  const attrs = data.ageRatingDeclaration.attributes;
+  const contentFields = [
+    "alcoholTobaccoOrDrugUseOrReferences",
+    "horrorOrFearThemes",
+    "matureOrSuggestiveThemes",
+    "profanityOrCrudeHumor",
+    "sexualContentGraphicAndNudity",
+    "sexualContentOrNudity",
+    "violenceCartoonOrFantasy",
+    "violenceRealistic",
+    "violenceRealisticProlongedGraphicOrSadistic",
+    "gamblingSimulated"
+  ];
+  const allNone = contentFields.every((field) => {
+    const value = attrs[field];
+    return value === null || value === NONE_VALUE || value === "INFREQUENT_OR_MILD";
+  });
+  const allNull = contentFields.every((field) => attrs[field] === null);
+  if (allNull) {
+    findings.push({
+      id: "AGE-002",
+      module: "age-rating",
+      severity: "high",
+      title: "Age rating fields appear unset",
+      message: "All age rating content descriptors are null, suggesting the questionnaire may not have been completed.",
+      remedy: "Complete the age rating questionnaire in App Store Connect > App Information > Age Rating."
+    });
+  } else if (allNone) {
+    findings.push({
+      id: "AGE-003",
+      module: "age-rating",
+      severity: "info",
+      title: "All age rating fields set to minimal",
+      message: "All content descriptors are set to NONE or INFREQUENT_OR_MILD. Verify this accurately reflects your app's content.",
+      remedy: "Review the age rating questionnaire to ensure it accurately represents your app's content."
+    });
+  }
+  if (attrs.gambling === true && (!attrs.gamblingSimulated || attrs.gamblingSimulated === NONE_VALUE)) {
+    findings.push({
+      id: "AGE-004",
+      module: "age-rating",
+      severity: "critical",
+      title: "Gambling flag set without proper classification",
+      message: "The gambling flag is enabled but simulated gambling content descriptor is not configured. This inconsistency may cause review issues.",
+      remedy: "Review the gambling-related fields in the age rating to ensure consistency."
+    });
+  }
+  if (attrs.unrestrictedWebAccess === true) {
+    findings.push({
+      id: "AGE-005",
+      module: "age-rating",
+      severity: "info",
+      title: "Unrestricted web access enabled",
+      message: "Your app is flagged as providing unrestricted web access. This increases the age rating. Ensure this is intentional.",
+      remedy: "If your app doesn't provide a general web browser, consider disabling this flag to lower the age rating."
+    });
+  }
+  if (attrs.seventeenPlus === true) {
+    findings.push({
+      id: "AGE-006",
+      module: "age-rating",
+      severity: "info",
+      title: "App rated 17+",
+      message: "Your app is flagged as 17+. This significantly limits your audience. Ensure this is necessary.",
+      remedy: "If possible, review whether 17+ content can be gated or made optional to lower the base age rating."
+    });
+  }
+  if (attrs.kidsAgeBand !== null && attrs.kidsAgeBand !== void 0) {
+    const hasMatureContent = attrs.violenceRealistic && attrs.violenceRealistic !== NONE_VALUE || attrs.sexualContentOrNudity && attrs.sexualContentOrNudity !== NONE_VALUE || attrs.profanityOrCrudeHumor && attrs.profanityOrCrudeHumor !== NONE_VALUE && attrs.profanityOrCrudeHumor !== "INFREQUENT_OR_MILD";
+    if (hasMatureContent) {
+      findings.push({
+        id: "AGE-007",
+        module: "age-rating",
+        severity: "critical",
+        title: "Kids age band with mature content flags",
+        message: "Your app targets kids (Kids Age Band is set) but also has mature content descriptors. This is an inconsistency that will likely cause rejection.",
+        remedy: "Either remove the Kids Age Band setting or adjust the content descriptors to be appropriate for children."
+      });
+    }
+  }
+  return {
+    module: "age-rating",
+    label: "Age Rating",
+    icon: "\u{1F51E}",
+    findings,
+    duration: Date.now() - start
+  };
+}
+
+// src/auditors/subtitle.ts
+var GENERIC_WORDS = [
+  "best",
+  "great",
+  "amazing",
+  "awesome",
+  "top",
+  "number one",
+  "#1",
+  "the best",
+  "most popular",
+  "world's",
+  "leading",
+  "ultimate",
+  "premium",
+  "pro",
+  "simple",
+  "easy"
+];
+function auditSubtitle(data) {
+  const start = Date.now();
+  const findings = [];
+  for (const loc of data.appInfoLocalizations) {
+    const locale = loc.attributes.locale;
+    const subtitle = loc.attributes.subtitle;
+    const appName = loc.attributes.name;
+    if (!subtitle || subtitle.trim().length === 0) {
+      findings.push({
+        id: "SUB-001",
+        module: "subtitle",
+        severity: "warning",
+        title: `Missing subtitle for locale \`${locale}\``,
+        message: `No subtitle is set for ${locale}. Subtitles appear below the app name in search results and improve discoverability.`,
+        locale,
+        remedy: `Add a compelling subtitle (max 30 chars) for ${locale} that highlights your app's key value proposition.`
+      });
+      continue;
+    }
+    if (subtitle.trim().length < 10) {
+      findings.push({
+        id: "SUB-002",
+        module: "subtitle",
+        severity: "info",
+        title: `Subtitle too short for locale \`${locale}\``,
+        message: `The subtitle for ${locale} is only ${subtitle.trim().length} characters ("${subtitle.trim()}"). Consider using more of the 30-character limit.`,
+        locale,
+        remedy: `Expand the subtitle for ${locale} to better utilize the 30-character limit.`
+      });
+    }
+    if (appName && subtitle.toLowerCase().includes(appName.toLowerCase())) {
+      findings.push({
+        id: "SUB-003",
+        module: "subtitle",
+        severity: "warning",
+        title: `Subtitle repeats app name for locale \`${locale}\``,
+        message: `The subtitle for ${locale} ("${subtitle}") contains the app name ("${appName}"). This wastes valuable subtitle space and may trigger review flags.`,
+        locale,
+        remedy: `Use the subtitle to add new information, not repeat the app name. Focus on features or benefits.`
+      });
+    }
+    const lowerSubtitle = subtitle.toLowerCase();
+    const matchedGeneric = GENERIC_WORDS.find((word) => lowerSubtitle.includes(word));
+    if (matchedGeneric) {
+      findings.push({
+        id: "SUB-004",
+        module: "subtitle",
+        severity: "warning",
+        title: `Generic subtitle for locale \`${locale}\``,
+        message: `The subtitle for ${locale} ("${subtitle}") contains the generic term "${matchedGeneric}". Apple may flag superlative or subjective claims.`,
+        locale,
+        remedy: `Replace generic terms with specific, factual descriptions of what your app does.`
+      });
+    }
+    if (subtitle.length > 30) {
+      findings.push({
+        id: "SUB-005",
+        module: "subtitle",
+        severity: "high",
+        title: `Subtitle too long for locale \`${locale}\``,
+        message: `The subtitle for ${locale} is ${subtitle.length} characters, exceeding the 30-character limit. It will be truncated.`,
+        locale,
+        remedy: `Shorten the subtitle for ${locale} to 30 characters or fewer.`
+      });
+    }
+  }
+  return {
+    module: "subtitle",
+    label: "Subtitle",
+    icon: "\u{1F4AC}",
+    findings,
+    duration: Date.now() - start
+  };
+}
+
+// src/auditors/privacy.ts
+function auditPrivacy(data) {
+  const start = Date.now();
+  const findings = [];
+  for (const loc of data.appInfoLocalizations) {
+    const locale = loc.attributes.locale;
+    if (!loc.attributes.privacyPolicyUrl || loc.attributes.privacyPolicyUrl.trim().length === 0) {
+      findings.push({
+        id: "PRV-001",
+        module: "privacy",
+        severity: "critical",
+        title: `Missing privacy policy URL for locale \`${locale}\``,
+        message: `No privacy policy URL is set for ${locale}. A valid privacy policy URL is required for all apps since October 2018.`,
+        locale,
+        remedy: `Add a publicly accessible privacy policy URL for ${locale} in App Store Connect > App Information.`
+      });
+      continue;
+    }
+    const url = loc.attributes.privacyPolicyUrl.trim();
+    try {
+      new URL(url);
+    } catch {
+      findings.push({
+        id: "PRV-002",
+        module: "privacy",
+        severity: "high",
+        title: `Invalid privacy policy URL for locale \`${locale}\``,
+        message: `The privacy policy URL for ${locale} ("${url}") is not a valid URL format.`,
+        locale,
+        remedy: `Fix the privacy policy URL format for ${locale}. It should be a full URL starting with https://`
+      });
+      continue;
+    }
+    if (!url.startsWith("https://")) {
+      findings.push({
+        id: "PRV-003",
+        module: "privacy",
+        severity: "warning",
+        title: `Privacy policy URL not HTTPS for locale \`${locale}\``,
+        message: `The privacy policy URL for ${locale} uses HTTP instead of HTTPS. Apple recommends HTTPS for all URLs.`,
+        locale,
+        remedy: `Update the privacy policy URL for ${locale} to use HTTPS.`
+      });
+    }
+  }
+  const urls = data.appInfoLocalizations.map((l) => l.attributes.privacyPolicyUrl?.trim()).filter(Boolean);
+  if (urls.length > 1) {
+    const uniqueUrls = new Set(urls);
+    if (uniqueUrls.size > 3 && uniqueUrls.size === urls.length) {
+      findings.push({
+        id: "PRV-004",
+        module: "privacy",
+        severity: "info",
+        title: "Many unique privacy policy URLs",
+        message: `Found ${uniqueUrls.size} unique privacy policy URLs across ${urls.length} localizations. Verify each is correct and accessible.`,
+        remedy: "Review all privacy policy URLs to ensure they point to valid, locale-appropriate privacy policies."
+      });
+    }
+  }
+  const hasPrivacyChoicesUrl = data.appInfoLocalizations.some(
+    (l) => l.attributes.privacyChoicesUrl && l.attributes.privacyChoicesUrl.trim().length > 0
+  );
+  if (!hasPrivacyChoicesUrl) {
+    findings.push({
+      id: "PRV-005",
+      module: "privacy",
+      severity: "info",
+      title: "No privacy choices URL configured",
+      message: "No privacy choices URL is set. This is optional but recommended if your app collects personal data and you offer data management options.",
+      remedy: "Consider adding a privacy choices URL where users can manage their data preferences."
+    });
+  }
+  return {
+    module: "privacy",
+    label: "Privacy",
+    icon: "\u{1F512}",
+    findings,
+    duration: Date.now() - start
+  };
+}
+
+// src/auditors/subscription.ts
+function auditSubscriptions(data) {
+  const start = Date.now();
+  const findings = [];
+  const appLocales = new Set(data.versionLocalizations.map((l) => l.attributes.locale));
+  for (const groupLocData of data.subscriptionGroupLocalizations) {
+    const { groupId, localizations } = groupLocData;
+    const group = data.subscriptionGroups.find((g) => g.id === groupId);
+    const groupName = group?.attributes.referenceName || groupId;
+    const groupLocales = new Set(localizations.map((l) => l.attributes.locale));
+    for (const locale of appLocales) {
+      if (!groupLocales.has(locale)) {
+        findings.push({
+          id: "SUBS-001",
+          module: "subscription",
+          severity: "high",
+          title: `Subscription group "${groupName}" missing \`${locale}\` localization`,
+          message: `The subscription group "${groupName}" has no display name for ${locale}. This can cause "Missing Metadata" states for subscriptions in this group.`,
+          locale,
+          remedy: `Add a display name for ${locale} under the subscription group "${groupName}" in App Store Connect.`
+        });
+      }
+    }
+    for (const loc of localizations) {
+      if (!loc.attributes.name || loc.attributes.name.trim().length === 0) {
+        findings.push({
+          id: "SUBS-002",
+          module: "subscription",
+          severity: "high",
+          title: `Subscription group "${groupName}" has empty name for \`${loc.attributes.locale}\``,
+          message: `The display name for subscription group "${groupName}" in ${loc.attributes.locale} is empty.`,
+          locale: loc.attributes.locale,
+          remedy: `Set a display name for the subscription group "${groupName}" in ${loc.attributes.locale}.`
+        });
+      }
+    }
+  }
+  for (const sub of data.subscriptions) {
+    const subName = sub.attributes.name || sub.attributes.productId;
+    const subLocales = new Set(sub.localizations.map((l) => l.attributes.locale));
+    for (const loc of sub.localizations) {
+      if (!loc.attributes.name || loc.attributes.name.trim().length === 0) {
+        findings.push({
+          id: "SUBS-003",
+          module: "subscription",
+          severity: "critical",
+          title: `Subscription "${subName}" missing display name for \`${loc.attributes.locale}\``,
+          message: `The subscription "${subName}" has no localized display name for ${loc.attributes.locale}. This is required for the subscription sheet.`,
+          locale: loc.attributes.locale,
+          remedy: `Add a display name for "${subName}" in ${loc.attributes.locale}.`
+        });
+      }
+    }
+    for (const loc of sub.localizations) {
+      if (!loc.attributes.description || loc.attributes.description.trim().length === 0) {
+        findings.push({
+          id: "SUBS-004",
+          module: "subscription",
+          severity: "critical",
+          title: `Subscription "${subName}" missing description for \`${loc.attributes.locale}\``,
+          message: `The subscription "${subName}" has no localized description for ${loc.attributes.locale}. This is required for App Store display.`,
+          locale: loc.attributes.locale,
+          remedy: `Add a description for "${subName}" in ${loc.attributes.locale}.`
+        });
+      }
+    }
+    for (const locale of appLocales) {
+      if (!subLocales.has(locale)) {
+        findings.push({
+          id: "SUBS-005",
+          module: "subscription",
+          severity: "high",
+          title: `Subscription "${subName}" missing \`${locale}\` localization`,
+          message: `Your app supports ${locale} but the subscription "${subName}" has no localization for it.`,
+          locale,
+          remedy: `Add localized metadata for "${subName}" in ${locale}.`
+        });
+      }
+    }
+  }
+  for (const iap of data.inAppPurchases) {
+    const iapName = iap.attributes.name || iap.attributes.productId;
+    const iapLocales = new Set(iap.localizations.map((l) => l.attributes.locale));
+    for (const loc of iap.localizations) {
+      if (!loc.attributes.name || loc.attributes.name.trim().length === 0) {
+        findings.push({
+          id: "SUBS-006",
+          module: "subscription",
+          severity: "critical",
+          title: `IAP "${iapName}" missing display name for \`${loc.attributes.locale}\``,
+          message: `The in-app purchase "${iapName}" has no localized display name for ${loc.attributes.locale}.`,
+          locale: loc.attributes.locale,
+          remedy: `Add a display name for "${iapName}" in ${loc.attributes.locale}.`
+        });
+      }
+    }
+    for (const loc of iap.localizations) {
+      if (!loc.attributes.description || loc.attributes.description.trim().length === 0) {
+        findings.push({
+          id: "SUBS-007",
+          module: "subscription",
+          severity: "warning",
+          title: `IAP "${iapName}" missing description for \`${loc.attributes.locale}\``,
+          message: `The in-app purchase "${iapName}" has no localized description for ${loc.attributes.locale}.`,
+          locale: loc.attributes.locale,
+          remedy: `Add a description for "${iapName}" in ${loc.attributes.locale}.`
+        });
+      }
+    }
+    for (const locale of appLocales) {
+      if (!iapLocales.has(locale)) {
+        findings.push({
+          id: "SUBS-008",
+          module: "subscription",
+          severity: "high",
+          title: `IAP "${iapName}" missing \`${locale}\` localization`,
+          message: `Your app supports ${locale} but the IAP "${iapName}" has no localization for it.`,
+          locale,
+          remedy: `Add localized metadata for "${iapName}" in ${locale}.`
+        });
+      }
+    }
+  }
+  return {
+    module: "subscription",
+    label: "Subscriptions & IAP",
+    icon: "\u{1F4B3}",
+    findings,
+    duration: Date.now() - start
+  };
+}
+
+// src/auditors/storefront.ts
+var MAJOR_MARKETS = [
+  { id: "USA", name: "United States" },
+  { id: "GBR", name: "United Kingdom" },
+  { id: "DEU", name: "Germany" },
+  { id: "FRA", name: "France" },
+  { id: "JPN", name: "Japan" },
+  { id: "CHN", name: "China" },
+  { id: "KOR", name: "South Korea" },
+  { id: "CAN", name: "Canada" },
+  { id: "AUS", name: "Australia" },
+  { id: "BRA", name: "Brazil" },
+  { id: "IND", name: "India" },
+  { id: "ITA", name: "Italy" },
+  { id: "ESP", name: "Spain" },
+  { id: "NLD", name: "Netherlands" },
+  { id: "TUR", name: "Turkey" }
+];
+function auditStorefront(data) {
+  const start = Date.now();
+  const findings = [];
+  const territoryIds = new Set(data.availableTerritories.map((t) => t.id));
+  const totalTerritories = data.availableTerritories.length;
+  if (totalTerritories === 0) {
+    findings.push({
+      id: "STR-001",
+      module: "storefront",
+      severity: "high",
+      title: "No territory availability data found",
+      message: "Could not determine which territories your app is available in.",
+      remedy: "Check App Store Connect > Pricing and Availability to configure territories."
+    });
+  } else if (totalTerritories < 10) {
+    findings.push({
+      id: "STR-002",
+      module: "storefront",
+      severity: "warning",
+      title: `Limited territory coverage (${totalTerritories} territories)`,
+      message: `Your app is available in only ${totalTerritories} territories. Apple supports 175+ storefronts.`,
+      remedy: "Consider expanding availability to more territories to increase your potential audience."
+    });
+  } else if (totalTerritories < 50) {
+    findings.push({
+      id: "STR-003",
+      module: "storefront",
+      severity: "info",
+      title: `Moderate territory coverage (${totalTerritories} territories)`,
+      message: `Your app is available in ${totalTerritories} territories. You could reach more users by expanding.`,
+      remedy: "Review if there are additional markets worth targeting."
+    });
+  }
+  if (totalTerritories > 0) {
+    const missingMajor = MAJOR_MARKETS.filter((m) => !territoryIds.has(m.id));
+    if (missingMajor.length > 0) {
+      const marketList = missingMajor.map((m) => m.name).join(", ");
+      findings.push({
+        id: "STR-004",
+        module: "storefront",
+        severity: missingMajor.length > 5 ? "warning" : "info",
+        title: `Missing ${missingMajor.length} major market(s)`,
+        message: `Your app is not available in: ${marketList}. These are among the highest-revenue App Store markets.`,
+        remedy: `Consider making your app available in these markets: ${marketList}.`
+      });
+    }
+  }
+  const localeToTerritory = {
+    "en-US": "USA",
+    "en-GB": "GBR",
+    "de-DE": "DEU",
+    "fr-FR": "FRA",
+    "ja": "JPN",
+    "zh-Hans": "CHN",
+    "ko": "KOR",
+    "pt-BR": "BRA",
+    "it": "ITA",
+    "es-ES": "ESP",
+    "es-MX": "MEX",
+    "nl-NL": "NLD",
+    "tr": "TUR",
+    "ru": "RUS",
+    "ar-SA": "SAU",
+    "th": "THA",
+    "vi": "VNM",
+    "id": "IDN",
+    "ms": "MYS"
+  };
+  const appLocales = data.versionLocalizations.map((l) => l.attributes.locale);
+  for (const locale of appLocales) {
+    const territory = localeToTerritory[locale];
+    if (territory && totalTerritories > 0 && !territoryIds.has(territory)) {
+      findings.push({
+        id: "STR-005",
+        module: "storefront",
+        severity: "warning",
+        title: `Localized for \`${locale}\` but not available in corresponding territory`,
+        message: `Your app has ${locale} localization but is not available in the corresponding territory. The localization effort may be wasted.`,
+        locale,
+        remedy: `Consider making your app available in the territory that corresponds to the ${locale} localization, or remove the unused localization.`
+      });
+    }
+  }
+  return {
+    module: "storefront",
+    label: "Storefront Coverage",
+    icon: "\u{1F310}",
+    findings,
+    duration: Date.now() - start
+  };
+}
+
+// src/auditors/review-info.ts
+function auditReviewInfo(data) {
+  const start = Date.now();
+  const findings = [];
+  if (!data.reviewDetail) {
+    findings.push({
+      id: "REV-001",
+      module: "review-info",
+      severity: "warning",
+      title: "No review detail found",
+      message: "Could not find App Store review detail information for this version. This section helps the review team understand your app.",
+      remedy: "Add review information in App Store Connect > App Store > Version > App Review Information."
+    });
+    return {
+      module: "review-info",
+      label: "Review Info",
+      icon: "\u{1F4CB}",
+      findings,
+      duration: Date.now() - start
+    };
+  }
+  const attrs = data.reviewDetail.attributes;
+  const hasContact = attrs.contactFirstName && attrs.contactFirstName.trim().length > 0 || attrs.contactEmail && attrs.contactEmail.trim().length > 0 || attrs.contactPhone && attrs.contactPhone.trim().length > 0;
+  if (!hasContact) {
+    findings.push({
+      id: "REV-002",
+      module: "review-info",
+      severity: "high",
+      title: "Missing reviewer contact information",
+      message: "No contact information (name, email, or phone) is provided for the App Review team. If they have questions, they won't be able to reach you quickly.",
+      remedy: "Add contact information (at minimum an email) in the App Review Information section."
+    });
+  } else {
+    if (!attrs.contactEmail || attrs.contactEmail.trim().length === 0) {
+      findings.push({
+        id: "REV-003",
+        module: "review-info",
+        severity: "warning",
+        title: "Missing reviewer contact email",
+        message: "No email address provided for the review team. Email is the most reliable way for reviewers to contact you.",
+        remedy: "Add a monitored email address to the App Review Information section."
+      });
+    }
+    if (!attrs.contactPhone || attrs.contactPhone.trim().length === 0) {
+      findings.push({
+        id: "REV-004",
+        module: "review-info",
+        severity: "info",
+        title: "Missing reviewer contact phone",
+        message: "No phone number provided for the review team.",
+        remedy: "Consider adding a phone number for faster communication during review."
+      });
+    }
+  }
+  if (attrs.demoAccountRequired === true) {
+    if (!attrs.demoAccountName || attrs.demoAccountName.trim().length === 0) {
+      findings.push({
+        id: "REV-005",
+        module: "review-info",
+        severity: "critical",
+        title: "Demo account required but username is missing",
+        message: "The app requires a demo account for review but no username is provided. This will cause rejection.",
+        remedy: "Provide a working demo account username in App Review Information."
+      });
+    }
+    if (!attrs.demoAccountPassword || attrs.demoAccountPassword.trim().length === 0) {
+      findings.push({
+        id: "REV-006",
+        module: "review-info",
+        severity: "critical",
+        title: "Demo account required but password is missing",
+        message: "The app requires a demo account for review but no password is provided. This will cause rejection.",
+        remedy: "Provide a working demo account password in App Review Information."
+      });
+    }
+  }
+  if (!attrs.notes || attrs.notes.trim().length === 0) {
+    findings.push({
+      id: "REV-007",
+      module: "review-info",
+      severity: "info",
+      title: "No review notes provided",
+      message: "The review notes field is empty. Notes can help the reviewer understand special features, required hardware, or complex flows.",
+      remedy: "Consider adding notes to guide the reviewer, especially for apps with sign-in, subscriptions, or specialized hardware."
+    });
+  }
+  return {
+    module: "review-info",
+    label: "Review Info",
+    icon: "\u{1F4CB}",
+    findings,
+    duration: Date.now() - start
+  };
+}
+
+// src/scoring/risk.ts
+var SEVERITY_WEIGHTS = {
+  critical: 15,
+  high: 8,
+  warning: 3,
+  info: 1
+};
+function calculateRiskScore(findings) {
+  const totalDeduction = findings.reduce((sum, finding) => {
+    return sum + SEVERITY_WEIGHTS[finding.severity];
+  }, 0);
+  return Math.max(0, 100 - totalDeduction);
+}
+function getGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 75) return "B";
+  if (score >= 50) return "C";
+  if (score >= 25) return "D";
+  return "F";
+}
+function getGradeLabel(score) {
+  if (score >= 90) return "Ship it!";
+  if (score >= 75) return "Almost ready";
+  if (score >= 50) return "Needs attention";
+  if (score >= 25) return "High risk";
+  return "Do not submit";
+}
+function getGradeEmoji(score) {
+  if (score >= 90) return "\u{1F7E2}";
+  if (score >= 75) return "\u{1F7E1}";
+  if (score >= 50) return "\u{1F7E0}";
+  if (score >= 25) return "\u{1F534}";
+  return "\u26D4";
+}
+function getSeverityEmoji(severity) {
+  switch (severity) {
+    case "critical":
+      return "\u{1F534}";
+    case "high":
+      return "\u{1F7E0}";
+    case "warning":
+      return "\u{1F7E1}";
+    case "info":
+      return "\u2139\uFE0F";
+  }
+}
+
+// src/auditors/index.ts
+var ALL_AUDITORS = [
+  { name: "localization", fn: auditLocalization },
+  { name: "screenshots", fn: auditScreenshots },
+  { name: "age-rating", fn: auditAgeRating },
+  { name: "subtitle", fn: auditSubtitle },
+  { name: "privacy", fn: auditPrivacy },
+  { name: "subscription", fn: auditSubscriptions },
+  { name: "storefront", fn: auditStorefront },
+  { name: "review-info", fn: auditReviewInfo }
+];
+function getAuditorNames() {
+  return ALL_AUDITORS.map((a) => a.name);
+}
+async function runAudit(data, options) {
+  let auditors = [...ALL_AUDITORS];
+  if (options.only.length > 0) {
+    auditors = auditors.filter((a) => options.only.includes(a.name));
+  }
+  if (options.skip.length > 0) {
+    auditors = auditors.filter((a) => !options.skip.includes(a.name));
+  }
+  const results = auditors.map((auditor) => auditor.fn(data));
+  const allFindings = results.flatMap((r) => r.findings);
+  const score = calculateRiskScore(allFindings);
+  const grade = getGrade(score);
+  const gradeLabel = getGradeLabel(score);
+  const critical = allFindings.filter((f) => f.severity === "critical").length;
+  const high = allFindings.filter((f) => f.severity === "high").length;
+  const warning = allFindings.filter((f) => f.severity === "warning").length;
+  const info = allFindings.filter((f) => f.severity === "info").length;
+  const passed = results.filter(
+    (r) => r.findings.filter((f) => f.severity !== "info").length === 0
+  ).length;
+  return {
+    appName: data.app.attributes.name,
+    bundleId: data.app.attributes.bundleId,
+    version: data.version.attributes.versionString,
+    platform: data.version.attributes.platform,
+    date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    score,
+    grade,
+    gradeLabel,
+    results,
+    findings: allFindings,
+    summary: {
+      critical,
+      high,
+      warning,
+      info,
+      total: allFindings.length,
+      passed
+    }
+  };
+}
+
+// src/reporter/terminal.ts
+import chalk from "chalk";
+function renderTerminal(report) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk.bold("  \u{1FA7A} ASC Doctor Report"));
+  lines.push(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  lines.push(`  ${chalk.dim("App:")}      ${chalk.white.bold(report.appName)} ${chalk.dim(`(${report.bundleId})`)}`);
+  lines.push(`  ${chalk.dim("Version:")}  ${chalk.white(report.version)} ${chalk.dim(`(${report.platform})`)}`);
+  lines.push(`  ${chalk.dim("Date:")}     ${chalk.white(report.date)}`);
+  lines.push("");
+  const emoji = getGradeEmoji(report.score);
+  const scoreColor = report.score >= 90 ? chalk.green : report.score >= 75 ? chalk.yellow : report.score >= 50 ? chalk.hex("#FF8C00") : chalk.red;
+  lines.push(`  ${chalk.dim("Score:")}    ${scoreColor.bold(`${report.score}/100`)} ${emoji} ${chalk.bold(report.grade)} \u2014 ${chalk.italic(report.gradeLabel)}`);
+  lines.push("");
+  lines.push(chalk.dim("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2510"));
+  lines.push(chalk.dim("  \u2502") + chalk.bold(" Module                  ") + chalk.dim("\u2502") + chalk.red.bold(" \u{1F534} ") + chalk.dim("\u2502") + chalk.hex("#FF8C00").bold(" \u{1F7E0} ") + chalk.dim("\u2502") + chalk.yellow.bold(" \u{1F7E1} ") + chalk.dim("\u2502") + chalk.blue.bold(" \u2139\uFE0F  ") + chalk.dim("\u2502"));
+  lines.push(chalk.dim("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2524"));
+  for (const result of report.results) {
+    const c = result.findings.filter((f) => f.severity === "critical").length;
+    const h = result.findings.filter((f) => f.severity === "high").length;
+    const w = result.findings.filter((f) => f.severity === "warning").length;
+    const i = result.findings.filter((f) => f.severity === "info").length;
+    const hasIssues = c + h + w > 0;
+    const nameStr = `${result.icon} ${result.label}`.padEnd(24);
+    const colorize = hasIssues ? (s) => s : chalk.green;
+    lines.push(
+      chalk.dim("  \u2502") + colorize(` ${nameStr}`) + chalk.dim("\u2502") + ` ${c > 0 ? chalk.red.bold(String(c).padStart(2)) : chalk.dim(" \xB7")} ` + chalk.dim("\u2502") + ` ${h > 0 ? chalk.hex("#FF8C00").bold(String(h).padStart(2)) : chalk.dim(" \xB7")} ` + chalk.dim("\u2502") + ` ${w > 0 ? chalk.yellow.bold(String(w).padStart(2)) : chalk.dim(" \xB7")} ` + chalk.dim("\u2502") + ` ${i > 0 ? chalk.blue(String(i).padStart(2)) : chalk.dim(" \xB7")} ` + chalk.dim("\u2502")
+    );
+  }
+  lines.push(chalk.dim("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2518"));
+  lines.push("");
+  lines.push(`  ${chalk.dim("Total:")} ${chalk.red.bold(`${report.summary.critical} critical`)}${chalk.dim(",")} ${chalk.hex("#FF8C00").bold(`${report.summary.high} high`)}${chalk.dim(",")} ${chalk.yellow.bold(`${report.summary.warning} warning`)}${chalk.dim(",")} ${chalk.blue(`${report.summary.info} info`)}`);
+  lines.push("");
+  const severityOrder = ["critical", "high", "warning", "info"];
+  const severityLabels = {
+    critical: "\u{1F534} Critical Findings",
+    high: "\u{1F7E0} High Findings",
+    warning: "\u{1F7E1} Warnings",
+    info: "\u2139\uFE0F  Informational"
+  };
+  for (const severity of severityOrder) {
+    const findings = report.findings.filter((f) => f.severity === severity);
+    if (findings.length === 0) continue;
+    lines.push(chalk.bold(`  ${severityLabels[severity]}`));
+    lines.push(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (const finding of findings) {
+      const emoji2 = getSeverityEmoji(finding.severity);
+      lines.push(`  ${emoji2} ${chalk.bold(`[${finding.id}]`)} ${finding.title}`);
+      lines.push(`     ${chalk.dim(finding.message)}`);
+      if (finding.remedy) {
+        lines.push(`     ${chalk.green("\u2192")} ${chalk.green(finding.remedy)}`);
+      }
+      lines.push("");
+    }
+  }
+  const passedModules = report.results.filter(
+    (r) => r.findings.filter((f) => f.severity !== "info").length === 0
+  );
+  if (passedModules.length > 0) {
+    lines.push(chalk.green.bold("  \u2705 Passed Checks"));
+    lines.push(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    for (const mod of passedModules) {
+      lines.push(`  ${chalk.green("\u2713")} ${mod.icon} ${mod.label}`);
+    }
+    lines.push("");
+  }
+  lines.push(chalk.dim("  Generated by ASC Doctor \u2022 https://github.com/aykutbey3543/ascdoc"));
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/reporter/markdown.ts
+function renderMarkdown(report) {
+  const lines = [];
+  lines.push("# \u{1FA7A} ASC Doctor Report");
+  lines.push("");
+  lines.push(`| | |`);
+  lines.push(`|---|---|`);
+  lines.push(`| **App** | ${report.appName} (\`${report.bundleId}\`) |`);
+  lines.push(`| **Version** | ${report.version} (${report.platform}) |`);
+  lines.push(`| **Date** | ${report.date} |`);
+  lines.push(`| **Risk Score** | **${report.score}/100** ${getGradeEmoji(report.score)} **${report.grade}** \u2014 ${report.gradeLabel} |`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push("| Module | \u{1F534} Critical | \u{1F7E0} High | \u{1F7E1} Warning | \u2139\uFE0F Info |");
+  lines.push("|--------|:-----------:|:-------:|:----------:|:------:|");
+  for (const result of report.results) {
+    const c = result.findings.filter((f) => f.severity === "critical").length;
+    const h = result.findings.filter((f) => f.severity === "high").length;
+    const w = result.findings.filter((f) => f.severity === "warning").length;
+    const i = result.findings.filter((f) => f.severity === "info").length;
+    const status = c + h + w === 0 ? " \u2705" : "";
+    lines.push(`| ${result.icon} ${result.label}${status} | ${c || "\u2014"} | ${h || "\u2014"} | ${w || "\u2014"} | ${i || "\u2014"} |`);
+  }
+  lines.push("");
+  const severityOrder = ["critical", "high", "warning", "info"];
+  const severityLabels = {
+    critical: "\u{1F534} Critical Findings",
+    high: "\u{1F7E0} High Findings",
+    warning: "\u{1F7E1} Warnings",
+    info: "\u2139\uFE0F Informational"
+  };
+  for (const severity of severityOrder) {
+    const findings = report.findings.filter((f) => f.severity === severity);
+    if (findings.length === 0) continue;
+    lines.push(`## ${severityLabels[severity]}`);
+    lines.push("");
+    for (const finding of findings) {
+      const emoji = getSeverityEmoji(finding.severity);
+      lines.push(`### ${emoji} [${finding.id}] ${finding.title}`);
+      lines.push("");
+      lines.push(finding.message);
+      lines.push("");
+      if (finding.remedy) {
+        lines.push(`> **Fix:** ${finding.remedy}`);
+        lines.push("");
+      }
+    }
+  }
+  const passedModules = report.results.filter(
+    (r) => r.findings.filter((f) => f.severity !== "info").length === 0
+  );
+  if (passedModules.length > 0) {
+    lines.push("## \u2705 Passed Checks");
+    lines.push("");
+    for (const mod of passedModules) {
+      lines.push(`- ${mod.icon} ${mod.label}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Generated by [ASC Doctor](https://github.com/aykutbey3543/ascdoc)*");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/reporter/json.ts
+function renderJSON(report) {
+  return JSON.stringify(
+    {
+      tool: "ascdoc",
+      version: "1.0.0",
+      app: {
+        name: report.appName,
+        bundleId: report.bundleId,
+        version: report.version,
+        platform: report.platform
+      },
+      date: report.date,
+      score: report.score,
+      grade: report.grade,
+      gradeLabel: report.gradeLabel,
+      summary: report.summary,
+      results: report.results.map((r) => ({
+        module: r.module,
+        label: r.label,
+        findingCount: r.findings.length,
+        duration: r.duration,
+        findings: r.findings.map((f) => ({
+          id: f.id,
+          severity: f.severity,
+          title: f.title,
+          message: f.message,
+          locale: f.locale || null,
+          remedy: f.remedy || null
+        }))
+      }))
+    },
+    null,
+    2
+  );
+}
+
+// src/demo/data.ts
+function generateDemoData() {
+  return {
+    app: {
+      type: "apps",
+      id: "1234567890",
+      attributes: {
+        name: "WeatherPulse",
+        bundleId: "com.example.weatherpulse",
+        sku: "WEATHERPULSE_2024",
+        primaryLocale: "en-US"
+      }
+    },
+    version: {
+      type: "appStoreVersions",
+      id: "ver-001",
+      attributes: {
+        platform: "IOS",
+        versionString: "2.4.0",
+        appStoreState: "PREPARE_FOR_SUBMISSION",
+        releaseType: "MANUAL",
+        createdDate: "2026-03-28T10:00:00Z"
+      }
+    },
+    versionLocalizations: [
+      {
+        type: "appStoreVersionLocalizations",
+        id: "vloc-en",
+        attributes: {
+          locale: "en-US",
+          description: "WeatherPulse gives you hyper-local weather forecasts with stunning visualizations. Track storms, check hourly conditions, and get severe weather alerts \u2014 all in a beautifully designed interface.",
+          keywords: "weather,forecast,rain,storm,temperature,wind,humidity,radar",
+          promotionalText: "Now with real-time lightning tracking! \u26A1",
+          whatsNew: "Bug fixes and performance improvements.",
+          marketingUrl: "https://weatherpulse.app",
+          supportUrl: "https://weatherpulse.app/support"
+        }
+      },
+      {
+        type: "appStoreVersionLocalizations",
+        id: "vloc-de",
+        attributes: {
+          locale: "de-DE",
+          description: "",
+          // ← Empty description!
+          keywords: "",
+          // ← Empty keywords!
+          promotionalText: null,
+          whatsNew: null,
+          marketingUrl: null,
+          supportUrl: null
+        }
+      },
+      {
+        type: "appStoreVersionLocalizations",
+        id: "vloc-ja",
+        attributes: {
+          locale: "ja",
+          description: "TODO: Add Japanese description here",
+          // ← Placeholder!
+          keywords: "weather,forecast",
+          promotionalText: null,
+          whatsNew: null,
+          marketingUrl: null,
+          supportUrl: null
+        }
+      },
+      {
+        type: "appStoreVersionLocalizations",
+        id: "vloc-fr",
+        attributes: {
+          locale: "fr-FR",
+          description: "WeatherPulse vous offre des pr\xE9visions m\xE9t\xE9o hyper-locales avec des visualisations \xE9poustouflantes.",
+          keywords: "m\xE9t\xE9o,pr\xE9visions,pluie,temp\xEAte,temp\xE9rature",
+          promotionalText: null,
+          whatsNew: null,
+          marketingUrl: null,
+          supportUrl: null
+        }
+      }
+    ],
+    appInfo: {
+      type: "appInfos",
+      id: "info-001",
+      attributes: {
+        appStoreState: "READY_FOR_DISTRIBUTION"
+      }
+    },
+    appInfoLocalizations: [
+      {
+        type: "appInfoLocalizations",
+        id: "iloc-en",
+        attributes: {
+          locale: "en-US",
+          name: "WeatherPulse",
+          subtitle: "Best Weather App",
+          // ← Generic subtitle!
+          privacyPolicyUrl: "https://weatherpulse.app/privacy",
+          privacyChoicesUrl: null,
+          privacyPolicyText: null
+        }
+      },
+      {
+        type: "appInfoLocalizations",
+        id: "iloc-de",
+        attributes: {
+          locale: "de-DE",
+          name: "WeatherPulse",
+          subtitle: null,
+          // ← Missing subtitle!
+          privacyPolicyUrl: "https://weatherpulse.app/privacy",
+          privacyChoicesUrl: null,
+          privacyPolicyText: null
+        }
+      },
+      {
+        type: "appInfoLocalizations",
+        id: "iloc-ja",
+        attributes: {
+          locale: "ja",
+          name: "WeatherPulse",
+          subtitle: "WP",
+          // ← Too short!
+          privacyPolicyUrl: null,
+          // ← Missing privacy policy!
+          privacyChoicesUrl: null,
+          privacyPolicyText: null
+        }
+      },
+      {
+        type: "appInfoLocalizations",
+        id: "iloc-fr",
+        attributes: {
+          locale: "fr-FR",
+          name: "WeatherPulse",
+          subtitle: "M\xE9t\xE9o en temps r\xE9el",
+          privacyPolicyUrl: "http://weatherpulse.app/privacy-fr",
+          // ← HTTP, not HTTPS!
+          privacyChoicesUrl: null,
+          privacyPolicyText: null
+        }
+      },
+      {
+        type: "appInfoLocalizations",
+        id: "iloc-ko",
+        attributes: {
+          locale: "ko",
+          name: "WeatherPulse",
+          subtitle: null,
+          privacyPolicyUrl: "https://weatherpulse.app/privacy",
+          privacyChoicesUrl: null,
+          privacyPolicyText: null
+        }
+      }
+    ],
+    ageRatingDeclaration: {
+      type: "ageRatingDeclarations",
+      id: "age-001",
+      attributes: {
+        alcoholTobaccoOrDrugUseOrReferences: "NONE",
+        contests: "NONE",
+        gamblingAndContests: false,
+        gambling: false,
+        gamblingSimulated: "NONE",
+        horrorOrFearThemes: "NONE",
+        matureOrSuggestiveThemes: "NONE",
+        medicalOrTreatmentInformation: "NONE",
+        profanityOrCrudeHumor: "NONE",
+        sexualContentGraphicAndNudity: "NONE",
+        sexualContentOrNudity: "NONE",
+        violenceCartoonOrFantasy: "NONE",
+        violenceRealistic: "NONE",
+        violenceRealisticProlongedGraphicOrSadistic: "NONE",
+        kidsAgeBand: null,
+        unrestrictedWebAccess: false,
+        seventeenPlus: false
+      }
+    },
+    screenshotSets: [
+      // en-US: Has iPhone 6.7" with 5 screenshots ✓
+      {
+        type: "appScreenshotSets",
+        id: "ss-en-67",
+        attributes: { screenshotDisplayType: "APP_IPHONE_67" },
+        screenshotCount: 5,
+        locale: "en-US"
+      },
+      // en-US: Has iPad 12.9" with 3 screenshots ✓
+      {
+        type: "appScreenshotSets",
+        id: "ss-en-ipad",
+        attributes: { screenshotDisplayType: "APP_IPAD_PRO_3GEN_129" },
+        screenshotCount: 3,
+        locale: "en-US"
+      },
+      // de-DE: iPhone set exists but EMPTY!
+      {
+        type: "appScreenshotSets",
+        id: "ss-de-67",
+        attributes: { screenshotDisplayType: "APP_IPHONE_67" },
+        screenshotCount: 0,
+        // ← Empty!
+        locale: "de-DE"
+      },
+      // ja: Only 1 screenshot (too few)
+      {
+        type: "appScreenshotSets",
+        id: "ss-ja-67",
+        attributes: { screenshotDisplayType: "APP_IPHONE_67" },
+        screenshotCount: 1,
+        // ← Too few
+        locale: "ja"
+      }
+      // fr-FR: No screenshots at all — not in the array!
+    ],
+    subscriptionGroups: [
+      {
+        type: "subscriptionGroups",
+        id: "sg-001",
+        attributes: { referenceName: "WeatherPulse Pro" }
+      }
+    ],
+    subscriptions: [
+      {
+        type: "subscriptions",
+        id: "sub-001",
+        attributes: {
+          name: "Monthly Pro",
+          productId: "com.example.weatherpulse.pro.monthly",
+          state: "APPROVED",
+          subscriptionPeriod: "ONE_MONTH",
+          reviewNote: null,
+          groupLevel: 1
+        },
+        localizations: [
+          {
+            type: "subscriptionLocalizations",
+            id: "subloc-en",
+            attributes: {
+              locale: "en-US",
+              name: "WeatherPulse Pro Monthly",
+              description: "Unlock all pro features with monthly billing.",
+              state: "APPROVED"
+            }
+          },
+          {
+            type: "subscriptionLocalizations",
+            id: "subloc-de",
+            attributes: {
+              locale: "de-DE",
+              name: "",
+              // ← Empty name!
+              description: "",
+              // ← Empty description!
+              state: "APPROVED"
+            }
+          }
+          // ja is missing entirely!
+          // fr-FR is missing entirely!
+        ]
+      }
+    ],
+    subscriptionGroupLocalizations: [
+      {
+        groupId: "sg-001",
+        localizations: [
+          {
+            type: "subscriptionGroupLocalizations",
+            id: "sgloc-en",
+            attributes: {
+              locale: "en-US",
+              name: "WeatherPulse Pro",
+              customAppName: null,
+              state: "APPROVED"
+            }
+          }
+          // de-DE, ja, fr-FR group localizations missing!
+        ]
+      }
+    ],
+    inAppPurchases: [
+      {
+        type: "inAppPurchases",
+        id: "iap-001",
+        attributes: {
+          name: "Radar Themes Pack",
+          productId: "com.example.weatherpulse.themes",
+          inAppPurchaseType: "NON_CONSUMABLE",
+          state: "APPROVED",
+          reviewNote: null
+        },
+        localizations: [
+          {
+            type: "inAppPurchaseLocalizations",
+            id: "iaploc-en",
+            attributes: {
+              locale: "en-US",
+              name: "Radar Themes Pack",
+              description: "Beautiful custom themes for the radar view.",
+              state: "APPROVED"
+            }
+          }
+        ]
+      }
+    ],
+    reviewDetail: {
+      type: "appStoreReviewDetails",
+      id: "rev-001",
+      attributes: {
+        contactFirstName: "John",
+        contactLastName: "Doe",
+        contactPhone: null,
+        // ← No phone
+        contactEmail: "john@weatherpulse.app",
+        demoAccountName: null,
+        demoAccountPassword: null,
+        demoAccountRequired: false,
+        notes: ""
+        // ← Empty notes
+      }
+    },
+    availableTerritories: [
+      { type: "territories", id: "USA", attributes: { currency: "USD" } },
+      { type: "territories", id: "GBR", attributes: { currency: "GBP" } },
+      { type: "territories", id: "DEU", attributes: { currency: "EUR" } },
+      { type: "territories", id: "FRA", attributes: { currency: "EUR" } },
+      { type: "territories", id: "CAN", attributes: { currency: "CAD" } },
+      { type: "territories", id: "AUS", attributes: { currency: "AUD" } }
+      // Missing: JPN, CHN, KOR, BRA, IND, ITA, ESP, NLD, TUR
+    ]
+  };
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+var program = new Command();
+program.name("ascdoc").description("\u{1FA7A} Release readiness auditor for App Store Connect").version(VERSION).option("--key-id <id>", "App Store Connect API Key ID").option("--issuer-id <id>", "App Store Connect API Issuer ID").option("--key <path>", "Path to .p8 private key file").option("--app-id <id>", "App ID (auto-detected if only one app)").option("--format <type>", "Output format: terminal, markdown, json", "terminal").option("--output <path>", "Save report to file").option("--only <modules>", "Run only these audit modules (comma-separated)").option("--skip <modules>", "Skip these audit modules (comma-separated)").option("--ci", "CI mode: exit with non-zero if score below --min-score", false).option("--min-score <score>", "Minimum score for CI mode (default: 75)", "75").option("--demo", "Run with demo data (no API key required)", false).option("--list-modules", "List available audit modules").action(async (options) => {
+  if (options.listModules) {
+    console.log("\n  Available audit modules:\n");
+    for (const name of getAuditorNames()) {
+      console.log(`    \u2022 ${name}`);
+    }
+    console.log("");
+    process.exit(0);
+  }
+  const config = resolveConfig({
+    keyId: options.keyId,
+    issuerId: options.issuerId,
+    keyPath: options.key,
+    appId: options.appId,
+    format: options.format,
+    output: options.output,
+    skip: options.skip ? options.skip.split(",").map((s) => s.trim()) : [],
+    only: options.only ? options.only.split(",").map((s) => s.trim()) : [],
+    ci: options.ci,
+    minScore: parseInt(options.minScore, 10),
+    demo: options.demo
+  });
+  if (config.format === "terminal") {
+    console.log("");
+    console.log(chalk2.bold("  \u{1FA7A} ASC Doctor") + chalk2.dim(` v${VERSION}`));
+    console.log(chalk2.dim("  Release readiness auditor for App Store Connect"));
+    console.log("");
+  }
+  const errors = validateConfig(config);
+  if (errors.length > 0) {
+    console.error(chalk2.red("\n  \u2716 Configuration errors:\n"));
+    for (const error of errors) {
+      console.error(chalk2.red(`    \u2022 ${error}`));
+    }
+    console.error("");
+    console.error(chalk2.dim("  Use --demo to try with sample data, or see --help for options."));
+    console.error("");
+    process.exit(1);
+  }
+  let appData;
+  if (config.demo) {
+    if (config.format === "terminal") {
+      console.log(chalk2.yellow("  \u26A0 Running in demo mode with sample data"));
+      console.log("");
+    }
+    appData = generateDemoData();
+  } else {
+    const spinner = config.format === "terminal" ? ora({ text: "Connecting to App Store Connect...", indent: 2 }).start() : null;
+    try {
+      const client = new APIClient({
+        keyId: config.keyId,
+        issuerId: config.issuerId,
+        keyPath: config.keyPath
+      });
+      if (spinner) spinner.text = "Fetching app data...";
+      appData = await fetchAppData(client, config.appId);
+      spinner?.succeed(`Fetched data for ${appData.app.attributes.name}`);
+    } catch (error) {
+      spinner?.fail("Failed to fetch data from App Store Connect");
+      console.error("");
+      console.error(chalk2.red(`  ${error instanceof Error ? error.message : String(error)}`));
+      console.error("");
+      process.exit(1);
+    }
+  }
+  const spinnerAudit = config.format === "terminal" ? ora({ text: "Running audits...", indent: 2 }).start() : null;
+  const report = await runAudit(appData, {
+    skip: config.skip,
+    only: config.only
+  });
+  spinnerAudit?.succeed(`Audit complete \u2014 ${report.summary.total} findings`);
+  if (config.format === "terminal") {
+    console.log("");
+  }
+  let output;
+  switch (config.format) {
+    case "markdown":
+      output = renderMarkdown(report);
+      break;
+    case "json":
+      output = renderJSON(report);
+      break;
+    default:
+      output = renderTerminal(report);
+  }
+  if (config.output) {
+    fs3.writeFileSync(config.output, output, "utf-8");
+    if (config.format === "terminal") {
+      console.log(chalk2.green(`  \u{1F4C4} Report saved to ${config.output}`));
+      console.log("");
+    }
+  } else {
+    console.log(output);
+  }
+  if (config.ci) {
+    if (report.score < config.minScore) {
+      process.exit(1);
+    }
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map