@fire-spark/cli 0.0.0-stage → 0.13.2

package/src/commands/doctor/client/catalog.ts

@@ -0,0 +1,179 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { Copy, Locale } from "../../../core/i18n";
+import { translate } from "../../../core/i18n";
+import { UsageError, readString } from "../../../core/options";
+import type { OptionValues } from "../../../core/options";
+
+export type Verification = "deterministic" | "mixed";
+
+export interface CatalogCheck {
+  id: string;
+  description: string;
+  acceptance: string;
+  channels: string[];
+  platforms: string[];
+  fixable: boolean;
+  required: boolean;
+  area: string;
+  notes: string;
+  verification: Verification;
+  howTo: string;
+}
+
+export interface CheckFilter {
+  channel?: string;
+  platform?: string;
+  requiredOnly: boolean;
+  area?: string;
+  verification?: Verification;
+}
+
+const file = join(dirname(fileURLToPath(import.meta.url)), "catalog.json");
+export const CATALOG = JSON.parse(readFileSync(file, "utf8")) as CatalogCheck[];
+
+const byId = new Map(CATALOG.map(check => [check.id, check]));
+
+export const checkById = (id: string) => {
+  return byId.get(id.toUpperCase());
+};
+
+const fold = (value: string) => {
+  return value.trim().toLowerCase().normalize("NFD").replace(/\p{M}/gu, "");
+};
+
+const label = (es: string, en: string, pt: string): Copy => {
+  return { "es-EC": es, "en-US": en, "pt-BR": pt };
+};
+
+const cacheEs = "Caché y admin remoto";
+const cacheEn = "Cache and remote admin";
+const cachePt = "Cache e admin remoto";
+const CACHE_LABEL = [cacheEs, cacheEn, cachePt] as const;
+const posEs = "POS caja y offline";
+const posEn = "POS register and offline";
+const posPt = "POS caixa e offline";
+const POS_LABEL = [posEs, posEn, posPt] as const;
+const tablesEs = "Mesas y reservas";
+const tablesEn = "Tables and reservations";
+const tablesPt = "Mesas e reservas";
+const TABLES_LABEL = [tablesEs, tablesEn, tablesPt] as const;
+
+export const AREA_LABELS: Record<string, Copy> = {
+  payments: label("Pagos", "Payments", "Pagamentos"),
+  orders: label("Órdenes", "Orders", "Pedidos"),
+  menu: label("Menú", "Menu", "Cardápio"),
+  overrides: label("Overrides", "Overrides", "Overrides"),
+  availability: label("Disponibilidad", "Availability", "Disponibilidade"),
+  cache: label(...CACHE_LABEL),
+  login: label("Login", "Login", "Login"),
+  cms: label("CMS", "CMS", "CMS"),
+  images: label("Imágenes", "Images", "Imagens"),
+  hardware: label("Hardware", "Hardware", "Hardware"),
+  printing: label("Impresión", "Printing", "Impressão"),
+  pos: label(...POS_LABEL),
+  chat: label("Chat", "Chat", "Chat"),
+  marketing: label("Marketing", "Marketing", "Marketing"),
+  admin: label("Admin", "Admin", "Admin"),
+  sdk: label("SDK y config", "SDK and config", "SDK e config"),
+  checkout: label("Checkout", "Checkout", "Checkout"),
+  tables: label(...TABLES_LABEL)
+};
+
+const AREA_ALIAS = new Map<string, string>();
+for (const [slug, copy] of Object.entries(AREA_LABELS)) {
+  AREA_ALIAS.set(fold(slug), slug);
+  for (const text of Object.values(copy)) AREA_ALIAS.set(fold(text), slug);
+}
+
+const channelA = ["kiosk", "pos", "web", "app", "chat"] as const;
+const channelB = ["call-center", "server", "dashboard"] as const;
+const CHANNELS = new Set([...channelA, ...channelB]);
+
+const PLATFORMS = new Set(["web", "android", "ios", "dashboard"]);
+
+const ver1 = ["deterministic", "deterministic"] as const;
+const ver2 = ["deterministica", "deterministic"] as const;
+const ver3 = ["mixed", "mixed"] as const;
+const ver4 = ["mezcla", "mixed"] as const;
+const ver5 = ["mista", "mixed"] as const;
+const verPairs = [ver1, ver2, ver3, ver4, ver5] as const;
+const VERIFICATION = new Map<string, Verification>(verPairs);
+
+const BAD_FILTER = {
+  "es-EC": "Valor desconocido para --{flag}: {value}",
+  "en-US": "Unknown value for --{flag}: {value}",
+  "pt-BR": "Valor desconhecido para --{flag}: {value}"
+} satisfies Copy;
+
+const badFilter = (locale: Locale, flag: string, value: string) => {
+  return new UsageError(translate(locale, BAD_FILTER, { flag, value }));
+};
+
+const token = (
+  locale: Locale,
+  value: string | undefined,
+  allowed: Map<string, string> | Set<string>,
+  flag: string
+) => {
+  if (!value) return undefined;
+  const key = fold(value);
+  if (allowed instanceof Map) {
+    const found = allowed.get(key);
+    if (!found) throw badFilter(locale, flag, value);
+    return found;
+  }
+  if (!allowed.has(key)) throw badFilter(locale, flag, value);
+  return key;
+};
+
+export const parseCheckFilter = (
+  values: OptionValues,
+  locale: Locale
+): CheckFilter => {
+  const channelRaw = readString(values, "channel");
+  const channel = token(locale, channelRaw, CHANNELS, "channel");
+  const platformRaw = readString(values, "platform");
+  const platform = token(locale, platformRaw, PLATFORMS, "platform");
+  const area = token(locale, readString(values, "area"), AREA_ALIAS, "area");
+  const raw = readString(values, "verification");
+  const verification = token(locale, raw, VERIFICATION, "verification");
+  const kind = verification as Verification | undefined;
+  const requiredOnly = values.required === true;
+  const b1 = { channel, platform, requiredOnly, area };
+  return { ...b1, verification: kind };
+};
+
+export const filterChecks = (checks: CatalogCheck[], filter: CheckFilter) => {
+  return checks.filter(check => {
+    if (filter.channel && !check.channels.includes(filter.channel)) {
+      return false;
+    }
+    if (filter.platform && !check.platforms.includes(filter.platform)) {
+      return false;
+    }
+    if (filter.requiredOnly && !check.required) return false;
+    if (filter.area && check.area !== filter.area) return false;
+    if (filter.verification && check.verification !== filter.verification) {
+      return false;
+    }
+    return true;
+  });
+};
+
+const detEs = "Determinística";
+const detEn = "Deterministic";
+const DETERMINISTIC = label(detEs, detEn, detEs);
+const MIXED = label("Mezcla", "Mixed", "Mista");
+
+export const areaLabel = (area: string, locale: Locale) => {
+  const copy = AREA_LABELS[area];
+  return copy ? translate(locale, copy) : area;
+};
+
+export const verificationLabel = (kind: Verification, locale: Locale) => {
+  const copy = kind === "mixed" ? MIXED : DETERMINISTIC;
+  return translate(locale, copy);
+};

package/src/commands/doctor/client/command.ts

@@ -0,0 +1,246 @@
+import { spawn } from "node:child_process";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+
+import type { Command, CommandContext } from "../../../core/command.types";
+import { renderCommandHelp } from "../../../core/help";
+import { translate } from "../../../core/i18n";
+import { UsageError, readString } from "../../../core/options";
+import { areaLabel, checkById, filterChecks } from "./catalog";
+import { CATALOG, parseCheckFilter, verificationLabel } from "./catalog";
+import type { CatalogCheck } from "./catalog";
+import { applyTargets, createConfig, fileExists, preflightGap } from "./config";
+import { promptAll, readConfig, readTargets } from "./config";
+import { resolveConfigPath, writeConfig } from "./config";
+import { COPY, DETAILS, DOCS_PAGE, SUMMARY, USAGE } from "./copy";
+import { CLIENT_OPTIONS } from "./options";
+import { BINDINGS, printRuns, runOne } from "./runner";
+import type { CheckRun } from "./runner";
+import type { YamlChannel } from "./yaml";
+
+const NAMES = new Set(["run", "init", "list", "show", "docs"]);
+
+const formatOf = (context: CommandContext) => {
+  const value = readString(context.options, "format") ?? "text";
+  if (value === "text" || value === "json") return value;
+  throw new UsageError(translate(context.locale, COPY.badFormat));
+};
+
+const wrote = (context: CommandContext, path: string) => {
+  const line = translate(context.locale, COPY.wrote, { path });
+  const json = readString(context.options, "format") === "json";
+  if (json) context.output.error(line);
+  else context.output.line(line);
+};
+
+const askerOf = (context: CommandContext) => {
+  const interactive = context.isTty === true;
+  const ask = async (question: string) => {
+    if (!interactive) return "";
+    if (context.ask) return context.ask(question);
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+      return await rl.question(question);
+    } finally {
+      rl.close();
+    }
+  };
+  return { ask, interactive };
+};
+
+const openPage = (url: string) => {
+  const command = process.platform === "darwin" ? "open" : "xdg-open";
+  try {
+    const child = spawn(command, [url], { stdio: "ignore", detached: true });
+    child.on("error", () => undefined);
+    child.unref();
+  } catch {
+    return;
+  }
+};
+
+const docs = (context: CommandContext) => {
+  const url = translate(context.locale, DOCS_PAGE);
+  context.output.line(translate(context.locale, COPY.docsLine, { url }));
+  if (context.isTty === true) openPage(url);
+  return 0;
+};
+
+const loadNew = async (context: CommandContext, path: string) => {
+  const flags = readTargets(context.options, context.locale);
+  const asker = askerOf(context);
+  const args = [context.cwd, flags, context.locale, asker] as const;
+  const file = await createConfig(...args);
+  await writeConfig(path, file);
+  wrote(context, path);
+  return file;
+};
+
+const loadExisting = async (context: CommandContext, path: string) => {
+  const flags = readTargets(context.options, context.locale);
+  const file = await readConfig(path, context.locale);
+  const channels = applyTargets(file.channels, flags, context.locale);
+  return { channels };
+};
+
+const selectedChecks = (context: CommandContext, ids: string[]) => {
+  const filter = parseCheckFilter(context.options, context.locale);
+  if (ids.length === 0) return filterChecks(CATALOG, filter);
+  const checks: CatalogCheck[] = [];
+  for (const id of ids) {
+    const check = checkById(id);
+    if (!check) {
+      const vars = { id };
+      const message = translate(context.locale, COPY.unknownCheck, vars);
+      throw new UsageError(message);
+    }
+    checks.push(check);
+  }
+  return filterChecks(checks, filter);
+};
+
+const showCheck = (context: CommandContext, check: CatalogCheck) => {
+  const { locale, output } = context;
+  const binding = BINDINGS[check.id];
+  const kind = binding ? binding.kind : "unbound";
+  const yes = translate(locale, COPY.yes);
+  const no = translate(locale, COPY.no);
+  const lines = [
+    check.id,
+    check.description,
+    check.acceptance,
+    `${check.channels.join(", ")}`,
+    `${check.platforms.join(", ")}`,
+    areaLabel(check.area, locale),
+    verificationLabel(check.verification, locale),
+    `${check.required ? yes : no}`,
+    `${check.fixable ? yes : no}`,
+    check.notes,
+    check.howTo,
+    kind
+  ];
+  for (const line of lines) output.line(line);
+};
+
+const listChecks = (context: CommandContext, checks: CatalogCheck[]) => {
+  const format = formatOf(context);
+  if (format === "json") {
+    const rows = checks.map(check => {
+      const b1 = { id: check.id, channels: check.channels };
+      const b2 = { platforms: check.platforms, required: check.required };
+      const b3 = { fixable: check.fixable, area: check.area };
+      const b4 = { verification: check.verification };
+      return { ...b1, ...b2, ...b3, ...b4 };
+    });
+    context.output.line(JSON.stringify(rows, null, 2));
+    return 0;
+  }
+  for (const check of checks) {
+    const area = areaLabel(check.area, context.locale);
+    const kind = verificationLabel(check.verification, context.locale);
+    context.output.line(`${check.id}  ${area}  ${kind}`);
+  }
+  return 0;
+};
+
+const runChecks = async (
+  context: CommandContext,
+  checks: CatalogCheck[],
+  channels: YamlChannel[],
+  ids: string[]
+) => {
+  const format = formatOf(context);
+  const fix = context.options.fix === true;
+  const strict = context.options.strict === true;
+  const named = new Set(ids.map(id => id.toUpperCase()));
+  const channelId = readString(context.options, "channel-id");
+  const b1 = { locale: context.locale, cwd: context.cwd, env: context.env };
+  const b2 = { channels, channelId, named, redactor: context.redactor };
+  const ctx = { ...b1, ...b2 };
+  const runs: CheckRun[] = [];
+  for (const check of checks) {
+    const outcome = await runOne(check, ctx, fix);
+    runs.push({ id: check.id, outcome });
+  }
+  return printRuns(context.output, context.locale, runs, format, strict);
+};
+
+const guard = (
+  context: CommandContext,
+  channels: Awaited<ReturnType<typeof loadExisting>>
+) => {
+  const gap = preflightGap(channels.channels, context.env);
+  if (!gap) return false;
+  const vars = { channel: gap.channel, field: gap.field };
+  const message = translate(context.locale, COPY.preflight, vars);
+  context.output.error(message);
+  return true;
+};
+
+export const runClientDoctor = async (
+  context: CommandContext,
+  command: Command
+) => {
+  const [name, ...rest] = context.positionals;
+  if (!name) {
+    context.output.line(renderCommandHelp(command, context.locale));
+    return 0;
+  }
+  if (!NAMES.has(name)) {
+    const vars = { name };
+    throw new UsageError(translate(context.locale, COPY.unknownCommand, vars));
+  }
+  if (rest.length > 0 && name !== "run" && name !== "show") {
+    const unknown = rest[0] ?? name;
+    const vars = { name: unknown };
+    const message = translate(context.locale, COPY.unknownCommand, vars);
+    throw new UsageError(message);
+  }
+  if (name === "docs") return docs(context);
+  const flag = readString(context.options, "config");
+  const path = await resolveConfigPath(context.cwd, flag, context.locale);
+  const exists = await fileExists(path);
+  if (name === "init") {
+    if (!exists) {
+      await loadNew(context, path);
+      return 0;
+    }
+    const flags = readTargets(context.options, context.locale);
+    const current = await readConfig(path, context.locale);
+    const merged = applyTargets(current.channels, flags, context.locale);
+    const asker = askerOf(context);
+    const args = [merged, flags, context.locale, asker, false] as const;
+    const channels = await promptAll(...args);
+    await writeConfig(path, { channels });
+    wrote(context, path);
+    return 0;
+  }
+  const read = exists ? loadExisting : loadNew;
+  const loaded = await read(context, path);
+  if (name === "list") return listChecks(context, selectedChecks(context, []));
+  if (name === "show") {
+    if (rest.length !== 1) {
+      throw new UsageError(translate(context.locale, COPY.showOne));
+    }
+    const checks = selectedChecks(context, rest);
+    const check = checks[0];
+    if (!check) throw new UsageError(translate(context.locale, COPY.none));
+    showCheck(context, check);
+    return 0;
+  }
+  if (guard(context, loaded)) return 1;
+  const checks = selectedChecks(context, rest);
+  if (checks.length === 0) {
+    throw new UsageError(translate(context.locale, COPY.none));
+  }
+  return runChecks(context, checks, loaded.channels, rest);
+};
+
+export const clientDoctorCommand: Command = {
+  name: "doctor",
+  usage: USAGE,
+  summary: SUMMARY,
+  details: DETAILS,
+  options: CLIENT_OPTIONS,
+  run: context => runClientDoctor(context, clientDoctorCommand)
+};