@gpc-cli/core 0.9.21 → 0.9.23

package/dist/index.js

@@ -242,11 +242,29 @@ function buildTestCase(item, commandName, index = 0) {
     };
   }
   const record = item;
-  const name = escapeXml(
-    String(
-      record["name"] ?? record["title"] ?? record["sku"] ?? record["id"] ?? record["productId"] ?? record["packageName"] ?? record["trackId"] ?? record["region"] ?? record["languageCode"] ?? `item-${index + 1}`
-    )
-  );
+  const CANDIDATE_KEYS = [
+    "name",
+    "title",
+    "sku",
+    "id",
+    "reviewId",
+    "productId",
+    "packageName",
+    "track",
+    "trackId",
+    "versionCode",
+    "region",
+    "languageCode"
+  ];
+  let resolvedName = `item-${index + 1}`;
+  for (const key of CANDIDATE_KEYS) {
+    const val = record[key];
+    if (val != null && val !== "" && val !== "-") {
+      resolvedName = String(val);
+      break;
+    }
+  }
+  const name = escapeXml(resolvedName);
   const classname = `gpc.${escapeXml(commandName)}`;
   const breached = record["breached"];
   if (breached === true) {
@@ -1329,8 +1347,8 @@ var ALL_IMAGE_TYPES = [
   "tvBanner"
 ];
 async function exportImages(client, packageName, dir, options) {
-  const { mkdir: mkdir5, writeFile: writeFile7 } = await import("fs/promises");
-  const { join: join7 } = await import("path");
+  const { mkdir: mkdir6, writeFile: writeFile8 } = await import("fs/promises");
+  const { join: join8 } = await import("path");
   const edit = await client.edits.insert(packageName);
   try {
     let languages;
@@ -1361,12 +1379,12 @@ async function exportImages(client, packageName, dir, options) {
       const batch = tasks.slice(i, i + concurrency);
       const results = await Promise.all(
         batch.map(async (task) => {
-          const dirPath = join7(dir, task.language, task.imageType);
-          await mkdir5(dirPath, { recursive: true });
+          const dirPath = join8(dir, task.language, task.imageType);
+          await mkdir6(dirPath, { recursive: true });
           const response = await fetch(task.url);
           const buffer = Buffer.from(await response.arrayBuffer());
-          const filePath = join7(dirPath, `${task.index}.png`);
-          await writeFile7(filePath, buffer);
+          const filePath = join8(dirPath, `${task.index}.png`);
+          await writeFile8(filePath, buffer);
           return buffer.length;
         })
       );
@@ -1404,6 +1422,7 @@ async function updateAppDetails(client, packageName, details) {
 // src/commands/migrate.ts
 import { readdir as readdir2, readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, access } from "fs/promises";
 import { join as join2 } from "path";
+var COMPLEX_RUBY_RE = /\b(begin|rescue|ensure|if |unless |case |while |until |for )\b/;
 async function fileExists(path) {
   try {
     await access(path);
@@ -1419,7 +1438,8 @@ async function detectFastlane(cwd) {
     hasMetadata: false,
     hasGemfile: false,
     lanes: [],
-    metadataLanguages: []
+    metadataLanguages: [],
+    parseWarnings: []
   };
   const fastlaneDir = join2(cwd, "fastlane");
   const hasFastlaneDir = await fileExists(fastlaneDir);
@@ -1435,13 +1455,20 @@ async function detectFastlane(cwd) {
       const entries = await readdir2(metadataDir, { withFileTypes: true });
       result.metadataLanguages = entries.filter((e) => e.isDirectory()).map((e) => e.name);
     } catch {
+      result.parseWarnings.push("Could not read metadata directory \u2014 check permissions");
     }
   }
   if (result.hasFastfile) {
     try {
       const content = await readFile3(fastfilePath, "utf-8");
       result.lanes = parseFastfile(content);
+      if (COMPLEX_RUBY_RE.test(content)) {
+        result.parseWarnings.push(
+          "Fastfile contains complex Ruby constructs (begin/rescue/if/unless/case). Lane detection may be incomplete \u2014 review MIGRATION.md and adjust manually."
+        );
+      }
     } catch {
+      result.parseWarnings.push("Could not read Fastfile \u2014 check permissions");
     }
   }
   if (result.hasAppfile) {
@@ -1451,6 +1478,7 @@ async function detectFastlane(cwd) {
       result.packageName = parsed.packageName;
       result.jsonKeyPath = parsed.jsonKeyPath;
     } catch {
+      result.parseWarnings.push("Could not read Appfile \u2014 check permissions");
     }
   }
   return result;
@@ -1481,8 +1509,9 @@ function mapLaneToGpc(name, actions, body) {
     const trackMatch = body.match(/track\s*:\s*["'](\w+)["']/);
     const rolloutMatch = body.match(/rollout\s*:\s*["']?([\d.]+)["']?/);
     if (rolloutMatch) {
-      const percentage = Math.round(parseFloat(rolloutMatch[1] ?? "0") * 100);
-      return `gpc releases promote --rollout ${percentage}`;
+      const raw = parseFloat(rolloutMatch[1] ?? "0");
+      const pct = raw > 1 ? Math.round(raw) : Math.round(raw * 100);
+      return `gpc releases upload --rollout ${pct}${trackMatch ? ` --track ${trackMatch[1]}` : ""}`;
     }
     if (trackMatch) {
       return `gpc releases upload --track ${trackMatch[1]}`;
@@ -1512,7 +1541,7 @@ function parseAppfile(content) {
 function generateMigrationPlan(detection) {
   const config = {};
   const checklist = [];
-  const warnings = [];
+  const warnings = [...detection.parseWarnings];
   if (detection.packageName) {
     config["app"] = detection.packageName;
   } else {
@@ -1521,44 +1550,61 @@ function generateMigrationPlan(detection) {
   if (detection.jsonKeyPath) {
     config["auth"] = { serviceAccount: detection.jsonKeyPath };
   } else {
-    checklist.push("Configure authentication: gpc auth setup");
+    checklist.push("Configure authentication: gpc auth login");
   }
   for (const lane of detection.lanes) {
     if (lane.gpcEquivalent) {
-      checklist.push(`Replace Fastlane lane "${lane.name}" with: ${lane.gpcEquivalent}`);
+      checklist.push(
+        `Replace Fastlane lane "${lane.name}" with: ${lane.gpcEquivalent} <your.aab>`
+      );
     }
     if (lane.actions.includes("capture_android_screenshots")) {
       warnings.push(
-        `Lane "${lane.name}" uses capture_android_screenshots which has no GPC equivalent. You will need to continue using Fastlane for screenshot capture or use a separate tool.`
+        `Lane "${lane.name}" uses capture_android_screenshots which has no GPC equivalent. Use a separate screenshot tool or check gpc plugins list for community plugins.`
+      );
+    }
+    if (lane.actions.length === 0 || lane.gpcEquivalent === void 0 && !lane.actions.includes("capture_android_screenshots")) {
+      warnings.push(
+        `Lane "${lane.name}" has no automatic GPC equivalent. Check \`gpc plugins list\` or the plugin SDK docs to build a custom command.`
       );
     }
   }
   if (detection.hasMetadata && detection.metadataLanguages.length > 0) {
+    const langs = detection.metadataLanguages.slice(0, 3).join(", ");
+    const more = detection.metadataLanguages.length > 3 ? ` (+${detection.metadataLanguages.length - 3} more)` : "";
     checklist.push(
-      `Migrate metadata for ${detection.metadataLanguages.length} language(s): gpc listings pull --dir metadata`
+      `Pull current metadata for ${detection.metadataLanguages.length} language(s) (${langs}${more}): gpc listings pull --dir fastlane/metadata/android`
+    );
+    checklist.push(
+      "Review pulled metadata, then push back: gpc listings push --dir fastlane/metadata/android"
     );
-    checklist.push("Review and push metadata: gpc listings push --dir metadata");
   }
   checklist.push("Run gpc doctor to verify your setup");
-  checklist.push("Test with --dry-run before making real changes");
+  checklist.push("Test each command with --dry-run before making real changes");
   if (detection.hasGemfile) {
     checklist.push("Remove Fastlane from your Gemfile once migration is complete");
   }
-  if (detection.lanes.some((l) => l.actions.includes("supply") || l.actions.includes("upload_to_play_store"))) {
-    checklist.push("Update CI/CD pipelines to use gpc commands instead of Fastlane lanes");
+  if (detection.lanes.some(
+    (l) => l.actions.includes("supply") || l.actions.includes("upload_to_play_store")
+  )) {
+    checklist.push("Update CI/CD pipelines to call gpc commands instead of Fastlane lanes");
   }
   return { config, checklist, warnings };
 }
 async function writeMigrationOutput(result, dir) {
   await mkdir2(dir, { recursive: true });
   const files = [];
-  const configPath = join2(dir, ".gpcrc.json");
-  await writeFile2(configPath, JSON.stringify(result.config, null, 2) + "\n", "utf-8");
-  files.push(configPath);
+  if (Object.keys(result.config).length > 0) {
+    const configPath = join2(dir, ".gpcrc.json");
+    await writeFile2(configPath, JSON.stringify(result.config, null, 2) + "\n", "utf-8");
+    files.push(configPath);
+  }
   const migrationPath = join2(dir, "MIGRATION.md");
   const lines = [
     "# Fastlane to GPC Migration",
     "",
+    "Generated by `gpc migrate fastlane`. Review and adjust before applying.",
+    "",
     "## Migration Checklist",
     ""
   ];
@@ -1570,7 +1616,7 @@ async function writeMigrationOutput(result, dir) {
     lines.push("## Warnings");
     lines.push("");
     for (const warning of result.warnings) {
-      lines.push(`- ${warning}`);
+      lines.push(`> \u26A0 ${warning}`);
     }
   }
   lines.push("");
@@ -1581,8 +1627,11 @@ async function writeMigrationOutput(result, dir) {
   lines.push("| `fastlane supply` | `gpc releases upload` / `gpc listings push` |");
   lines.push("| `upload_to_play_store` | `gpc releases upload` |");
   lines.push('| `supply(track: "internal")` | `gpc releases upload --track internal` |');
-  lines.push('| `supply(rollout: "0.1")` | `gpc releases promote --rollout 10` |');
-  lines.push("| `capture_android_screenshots` | No equivalent (use separate tool) |");
+  lines.push('| `supply(rollout: "0.1")` | `gpc releases upload --rollout 10` |');
+  lines.push("| `supply(skip_upload_aab: true)` | `gpc listings push` |");
+  lines.push("| `capture_android_screenshots` | No equivalent \u2014 use separate tool |");
+  lines.push("");
+  lines.push("See the full migration guide: https://yasserstudio.github.io/gpc/migration/from-fastlane");
   lines.push("");
   await writeFile2(migrationPath, lines.join("\n"), "utf-8");
   files.push(migrationPath);
@@ -1729,12 +1778,16 @@ var STANDARD_TRACKS = /* @__PURE__ */ new Set([
 var TRACK_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_:-]*$/;
 async function validatePreSubmission(options) {
   const checks = [];
+  const resultWarnings = [];
   const fileResult = await validateUploadFile(options.filePath);
   checks.push({
     name: "file",
     passed: fileResult.valid,
-    message: fileResult.valid ? `Valid ${fileResult.fileType} file (${formatSize3(fileResult.sizeBytes)})` : fileResult.errors.join("; ")
+    message: fileResult.valid ? `Valid ${fileResult.fileType.toUpperCase()} (${formatSize3(fileResult.sizeBytes)})` : fileResult.errors.join("; ")
   });
+  for (const w of fileResult.warnings) {
+    resultWarnings.push(w);
+  }
   if (options.mappingFile) {
     try {
       const stats = await stat5(options.mappingFile);
@@ -1786,7 +1839,8 @@ async function validatePreSubmission(options) {
   }
   return {
     valid: checks.every((c) => c.passed),
-    checks
+    checks,
+    warnings: resultWarnings
   };
 }
 function formatSize3(bytes) {
@@ -1955,23 +2009,22 @@ var METRIC_SET_METRICS = {
 function buildQuery(metricSet, options) {
   const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
   const days = options?.days ?? 30;
-  const end = /* @__PURE__ */ new Date();
-  end.setDate(end.getDate() - 1);
-  const start = new Date(end);
-  start.setDate(start.getDate() - days);
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const end = new Date(Date.now() - DAY_MS);
+  const start = new Date(Date.now() - DAY_MS - days * DAY_MS);
   const query = {
     metrics,
     timelineSpec: {
       aggregationPeriod: options?.aggregation ?? "DAILY",
       startTime: {
-        year: start.getFullYear(),
-        month: start.getMonth() + 1,
-        day: start.getDate()
+        year: start.getUTCFullYear(),
+        month: start.getUTCMonth() + 1,
+        day: start.getUTCDate()
       },
       endTime: {
-        year: end.getFullYear(),
-        month: end.getMonth() + 1,
-        day: end.getDate()
+        year: end.getUTCFullYear(),
+        month: end.getUTCMonth() + 1,
+        day: end.getUTCDate()
       }
     }
   };
@@ -2036,22 +2089,25 @@ async function searchVitalsErrors(reporting, packageName, options) {
   return reporting.searchErrorIssues(packageName, options?.filter, options?.maxResults);
 }
 async function compareVitalsTrend(reporting, packageName, metricSet, days = 7) {
-  const now = /* @__PURE__ */ new Date();
-  now.setDate(now.getDate() - 1);
-  const currentEnd = new Date(now);
-  const currentStart = new Date(now);
-  currentStart.setDate(currentStart.getDate() - days);
-  const previousEnd = new Date(currentStart);
-  previousEnd.setDate(previousEnd.getDate() - 1);
-  const previousStart = new Date(previousEnd);
-  previousStart.setDate(previousStart.getDate() - days);
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const nowMs = Date.now();
+  const baseMs = nowMs - 2 * DAY_MS;
+  const currentEnd = new Date(baseMs);
+  const currentStart = new Date(baseMs - days * DAY_MS);
+  const previousEnd = new Date(baseMs - days * DAY_MS - DAY_MS);
+  const previousStart = new Date(baseMs - days * DAY_MS - DAY_MS - days * DAY_MS);
   const metrics = METRIC_SET_METRICS[metricSet] ?? ["errorReportCount", "distinctUsers"];
+  const toApiDate2 = (d) => ({
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate()
+  });
   const makeQuery = (start, end) => ({
     metrics,
     timelineSpec: {
       aggregationPeriod: "DAILY",
-      startTime: { year: start.getFullYear(), month: start.getMonth() + 1, day: start.getDate() },
-      endTime: { year: end.getFullYear(), month: end.getMonth() + 1, day: end.getDate() }
+      startTime: toApiDate2(start),
+      endTime: toApiDate2(end)
     }
   });
   const [currentResult, previousResult] = await Promise.all([
@@ -2798,10 +2854,12 @@ function formatNotes(commits, maxLength) {
 ${bullets}`);
   }
   let text = sections.join("\n\n");
+  let truncated = false;
   if (text.length > maxLength) {
     text = text.slice(0, maxLength - 3) + "...";
+    truncated = true;
   }
-  return text;
+  return { text, truncated };
 }
 async function gitExec(args) {
   try {
@@ -2855,17 +2913,19 @@ async function generateNotesFromGit(options) {
       language,
       text: "No changes since last release.",
       commitCount: 0,
-      since
+      since,
+      truncated: false
     };
   }
   const subjects = logOutput.split("\n").filter((line) => line.length > 0);
   const commits = subjects.map(parseConventionalCommit);
-  const text = formatNotes(commits, maxLength);
+  const { text, truncated } = formatNotes(commits, maxLength);
   return {
     language,
     text,
     commitCount: subjects.length,
-    since
+    since,
+    truncated
   };
 }
 
@@ -3912,6 +3972,230 @@ function compareBundles(before, after) {
     categoryDeltas
   };
 }
+
+// src/commands/status.ts
+import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile7 } from "fs/promises";
+import { join as join7 } from "path";
+import { getCacheDir } from "@gpc-cli/config";
+var DEFAULT_TTL_SECONDS = 3600;
+function cacheFilePath(packageName) {
+  return join7(getCacheDir(), `status-${packageName}.json`);
+}
+async function loadStatusCache(packageName, ttlSeconds = DEFAULT_TTL_SECONDS) {
+  try {
+    const raw = await readFile10(cacheFilePath(packageName), "utf-8");
+    const entry = JSON.parse(raw);
+    const age = (Date.now() - new Date(entry.fetchedAt).getTime()) / 1e3;
+    if (age > (entry.ttl ?? ttlSeconds)) return null;
+    return { ...entry.data, cached: true };
+  } catch {
+    return null;
+  }
+}
+async function saveStatusCache(packageName, data, ttlSeconds = DEFAULT_TTL_SECONDS) {
+  try {
+    const dir = getCacheDir();
+    await mkdir5(dir, { recursive: true });
+    const entry = {
+      fetchedAt: data.fetchedAt,
+      ttl: ttlSeconds,
+      data
+    };
+    await writeFile7(cacheFilePath(packageName), JSON.stringify(entry, null, 2), { encoding: "utf-8", mode: 384 });
+  } catch {
+  }
+}
+var METRIC_SET_METRICS2 = {
+  crashRateMetricSet: ["crashRate", "userPerceivedCrashRate", "distinctUsers"],
+  anrRateMetricSet: ["anrRate", "userPerceivedAnrRate", "distinctUsers"],
+  slowStartRateMetricSet: ["slowStartRate", "distinctUsers"],
+  slowRenderingRateMetricSet: ["slowRenderingRate", "distinctUsers"]
+};
+var DEFAULT_THRESHOLDS = {
+  crashRate: 0.02,
+  anrRate: 0.01,
+  slowStartRate: 0.05,
+  slowRenderingRate: 0.1
+};
+var WARN_MARGIN = 0.2;
+function toApiDate(d) {
+  return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate() };
+}
+async function queryVitalForStatus(reporting, packageName, metricSet, days) {
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const baseMs = Date.now() - 2 * DAY_MS;
+  const end = new Date(baseMs);
+  const start = new Date(baseMs - days * DAY_MS);
+  const metrics = METRIC_SET_METRICS2[metricSet] ?? ["distinctUsers"];
+  const query = {
+    metrics,
+    timelineSpec: {
+      aggregationPeriod: "DAILY",
+      startTime: toApiDate(start),
+      endTime: toApiDate(end)
+    }
+  };
+  const result = await reporting.queryMetricSet(packageName, metricSet, query);
+  if (!result.rows || result.rows.length === 0) return void 0;
+  const values = result.rows.map((row) => {
+    const firstKey = Object.keys(row.metrics)[0];
+    return firstKey ? Number(row.metrics[firstKey]?.decimalValue?.value) : NaN;
+  }).filter((v) => !isNaN(v));
+  if (values.length === 0) return void 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function toVitalMetric(value, threshold) {
+  if (value === void 0) {
+    return { value: void 0, threshold, status: "unknown" };
+  }
+  if (value > threshold) return { value, threshold, status: "breach" };
+  if (value > threshold * (1 - WARN_MARGIN)) return { value, threshold, status: "warn" };
+  return { value, threshold, status: "ok" };
+}
+function computeReviewSentiment(reviews, windowDays) {
+  const now = Date.now();
+  const DAY_MS = 24 * 60 * 60 * 1e3;
+  const windowMs = windowDays * DAY_MS;
+  const prevWindowStart = now - 2 * windowMs;
+  const curWindowStart = now - windowMs;
+  const current = reviews.filter((r) => {
+    const uc = r.comments?.[0]?.userComment;
+    if (!uc) return false;
+    const ts = Number(uc.lastModified.seconds) * 1e3;
+    return ts >= curWindowStart;
+  });
+  const previous = reviews.filter((r) => {
+    const uc = r.comments?.[0]?.userComment;
+    if (!uc) return false;
+    const ts = Number(uc.lastModified.seconds) * 1e3;
+    return ts >= prevWindowStart && ts < curWindowStart;
+  });
+  const avgRating = (items) => {
+    const ratings = items.map((r) => r.comments?.[0]?.userComment?.starRating).filter((v) => v !== void 0 && v > 0);
+    if (ratings.length === 0) return void 0;
+    return Math.round(ratings.reduce((a, b) => a + b, 0) / ratings.length * 10) / 10;
+  };
+  const positiveCount = current.filter(
+    (r) => (r.comments?.[0]?.userComment?.starRating ?? 0) >= 4
+  ).length;
+  const positivePercent = current.length > 0 ? Math.round(positiveCount / current.length * 100) : void 0;
+  return {
+    windowDays,
+    averageRating: avgRating(current),
+    previousAverageRating: avgRating(previous),
+    totalNew: current.length,
+    positivePercent
+  };
+}
+async function getAppStatus(client, reporting, packageName, options = {}) {
+  const days = options.days ?? 7;
+  const thresholds = {
+    crashRate: options.vitalThresholds?.crashRate ?? DEFAULT_THRESHOLDS.crashRate,
+    anrRate: options.vitalThresholds?.anrRate ?? DEFAULT_THRESHOLDS.anrRate,
+    slowStartRate: options.vitalThresholds?.slowStartRate ?? DEFAULT_THRESHOLDS.slowStartRate,
+    slowRenderingRate: options.vitalThresholds?.slowRenderingRate ?? DEFAULT_THRESHOLDS.slowRenderingRate
+  };
+  const [releasesResult, crashesResult, anrResult, slowStartResult, slowRenderResult, reviewsResult] = await Promise.allSettled([
+    getReleasesStatus(client, packageName),
+    queryVitalForStatus(reporting, packageName, "crashRateMetricSet", days),
+    queryVitalForStatus(reporting, packageName, "anrRateMetricSet", days),
+    queryVitalForStatus(reporting, packageName, "slowStartRateMetricSet", days),
+    queryVitalForStatus(reporting, packageName, "slowRenderingRateMetricSet", days),
+    listReviews(client, packageName, { maxResults: 500 })
+  ]);
+  const rawReleases = releasesResult.status === "fulfilled" ? releasesResult.value : [];
+  const releases = rawReleases.map((r) => ({
+    track: r.track,
+    versionCode: r.versionCodes[r.versionCodes.length - 1] ?? "\u2014",
+    status: r.status,
+    userFraction: r.userFraction ?? null
+  }));
+  const crashValue = crashesResult.status === "fulfilled" ? crashesResult.value : void 0;
+  const anrValue = anrResult.status === "fulfilled" ? anrResult.value : void 0;
+  const slowStartValue = slowStartResult.status === "fulfilled" ? slowStartResult.value : void 0;
+  const slowRenderValue = slowRenderResult.status === "fulfilled" ? slowRenderResult.value : void 0;
+  const rawReviews = reviewsResult.status === "fulfilled" ? reviewsResult.value : [];
+  const reviews = computeReviewSentiment(rawReviews, 30);
+  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    packageName,
+    fetchedAt,
+    cached: false,
+    releases,
+    vitals: {
+      windowDays: days,
+      crashes: toVitalMetric(crashValue, thresholds.crashRate),
+      anr: toVitalMetric(anrValue, thresholds.anrRate),
+      slowStarts: toVitalMetric(slowStartValue, thresholds.slowStartRate),
+      slowRender: toVitalMetric(slowRenderValue, thresholds.slowRenderingRate)
+    },
+    reviews
+  };
+}
+function vitalIndicator(metric) {
+  if (metric.status === "unknown") return "?";
+  if (metric.status === "breach") return "\u2717";
+  if (metric.status === "warn") return "\u26A0";
+  return "\u2713";
+}
+function formatVitalValue(metric) {
+  if (metric.value === void 0) return "n/a";
+  return `${(metric.value * 100).toFixed(2)}%`;
+}
+function formatFraction(fraction) {
+  if (fraction === null) return "\u2014";
+  return `${Math.round(fraction * 100)}%`;
+}
+function formatRating(rating) {
+  if (rating === void 0) return "n/a";
+  return `\u2605 ${rating.toFixed(1)}`;
+}
+function formatTrend(current, previous) {
+  if (current === void 0 || previous === void 0) return "";
+  if (current > previous) return `  \u2191 from ${previous.toFixed(1)}`;
+  if (current < previous) return `  \u2193 from ${previous.toFixed(1)}`;
+  return "";
+}
+function formatStatusTable(status) {
+  const lines = [];
+  const cachedLabel = status.cached ? `  (cached ${new Date(status.fetchedAt).toLocaleTimeString()})` : `  (fetched ${new Date(status.fetchedAt).toLocaleTimeString()})`;
+  lines.push(`App: ${status.packageName}${cachedLabel}`);
+  lines.push("");
+  lines.push("RELEASES");
+  if (status.releases.length === 0) {
+    lines.push("  No releases found.");
+  } else {
+    const trackW = Math.max(10, ...status.releases.map((r) => r.track.length));
+    const versionW = Math.max(7, ...status.releases.map((r) => r.versionCode.length));
+    const statusW = Math.max(8, ...status.releases.map((r) => r.status.length));
+    for (const r of status.releases) {
+      lines.push(
+        `  ${r.track.padEnd(trackW)}  ${r.versionCode.padEnd(versionW)}  ${r.status.padEnd(statusW)}  ${formatFraction(r.userFraction)}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(`VITALS  (last ${status.vitals.windowDays} days)`);
+  const { crashes, anr, slowStarts, slowRender } = status.vitals;
+  lines.push(
+    `  crashes     ${formatVitalValue(crashes).padEnd(8)}  ${vitalIndicator(crashes)}    anr         ${formatVitalValue(anr).padEnd(8)}  ${vitalIndicator(anr)}`
+  );
+  lines.push(
+    `  slow starts ${formatVitalValue(slowStarts).padEnd(8)}  ${vitalIndicator(slowStarts)}    slow render ${formatVitalValue(slowRender).padEnd(8)}  ${vitalIndicator(slowRender)}`
+  );
+  lines.push("");
+  lines.push(`REVIEWS  (last ${status.reviews.windowDays} days)`);
+  const { averageRating, previousAverageRating, totalNew, positivePercent } = status.reviews;
+  const trend = formatTrend(averageRating, previousAverageRating);
+  const positiveStr = positivePercent !== void 0 ? `  ${positivePercent}% positive` : "";
+  lines.push(
+    `  ${formatRating(averageRating)}   ${totalNew} new${positiveStr}${trend}`
+  );
+  return lines.join("\n");
+}
+function statusHasBreach(status) {
+  return status.vitals.crashes.status === "breach" || status.vitals.anr.status === "breach" || status.vitals.slowStarts.status === "breach" || status.vitals.slowRender.status === "breach";
+}
 export {
   ApiError,
   ConfigError,
@@ -3981,9 +4265,11 @@ export {
   formatJunit,
   formatOutput,
   formatSlackPayload,
+  formatStatusTable,
   generateMigrationPlan,
   generateNotesFromGit,
   getAppInfo,
+  getAppStatus,
   getCountryAvailability,
   getDataSafety,
   getDeviceTier,
@@ -4034,6 +4320,7 @@ export {
   listTracks,
   listUsers,
   listVoidedPurchases,
+  loadStatusCache,
   migratePrices,
   parseAppfile,
   parseFastfile,
@@ -4055,11 +4342,13 @@ export {
   revokeSubscriptionPurchase,
   safePath,
   safePathWithin,
+  saveStatusCache,
   scaffoldPlugin,
   searchAuditEvents,
   searchVitalsErrors,
   sendWebhook,
   sortResults,
+  statusHasBreach,
   syncInAppProducts,
   updateAppDetails,
   updateDataSafety,