@fire-spark/cli 0.0.0-stage → 0.13.3

package/src/commands/doctor/client/repo.scan.ts

@@ -0,0 +1,142 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+
+const SKIP = new Set(["node_modules", ".git", "coverage"]);
+const MAX_FILES = 2000;
+const MAX_BYTES = 512000;
+
+export interface SourceFile {
+  rel: string;
+  body: string;
+}
+
+const textName = (name: string) => {
+  return /\.(json|ts|tsx|js|jsx|mjs|cjs|md|html|css|txt)$/.test(name);
+};
+
+export const readSources = async (root: string) => {
+  const found: SourceFile[] = [];
+  const visit = async (dir: string) => {
+    if (found.length >= MAX_FILES) return;
+    let names: { name: string; isDirectory: () => boolean }[] = [];
+    try {
+      names = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of names) {
+      if (found.length >= MAX_FILES) return;
+      if (SKIP.has(entry.name)) continue;
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await visit(path);
+        continue;
+      }
+      if (!textName(entry.name)) continue;
+      let body = "";
+      try {
+        body = await readFile(path, "utf8");
+      } catch {
+        continue;
+      }
+      if (body.length > MAX_BYTES) continue;
+      found.push({ rel: relative(root, path), body });
+    }
+  };
+  await visit(root);
+  return found;
+};
+
+const HEADING = /^##\s+v?(\d+\.\d+\.\d+)\s*(?:[-–:]\s*(.*))?$/;
+
+export interface ChangeNote {
+  version: string;
+  title: string;
+  description: string;
+}
+
+export const changelogNotes = (body: string) => {
+  const notes: ChangeNote[] = [];
+  let current: ChangeNote | null = null;
+  for (const line of body.split(/\r?\n/)) {
+    const match = HEADING.exec(line.trim());
+    if (match) {
+      if (current) notes.push(current);
+      const version = match[1] ?? "";
+      const title = match[2]?.trim() ?? "";
+      current = { version, title, description: "" };
+      continue;
+    }
+    if (!current || current.description || !line.trim()) continue;
+    current.description = line.trim();
+  }
+  if (current) notes.push(current);
+  return notes;
+};
+
+export const semverCmp = (left: string, right: string) => {
+  const a = left.split(".").map(part => Number(part));
+  const b = right.split(".").map(part => Number(part));
+  for (let i = 0; i < 3; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (Number.isNaN(av) || Number.isNaN(bv)) return 0;
+    if (av === bv) continue;
+    if (av > bv) return 1;
+    return -1;
+  }
+  return 0;
+};
+
+const SCOPES = ["dependencies", "devDependencies", "peerDependencies"];
+
+const isRecord = (value: unknown): value is Record<string, unknown> => {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+};
+
+export const workspaceIssues = (files: SourceFile[]) => {
+  const issues: string[] = [];
+  for (const file of files) {
+    if (!file.rel.endsWith("package.json")) continue;
+    let json: unknown;
+    try {
+      json = JSON.parse(file.body);
+    } catch {
+      continue;
+    }
+    if (!isRecord(json)) continue;
+    for (const scope of SCOPES) {
+      const bag = json[scope];
+      if (!isRecord(bag)) continue;
+      for (const [name, version] of Object.entries(bag)) {
+        if (!name.startsWith("@fire-spark/")) continue;
+        if (name === "@fire-spark/rn-ui") continue;
+        if (typeof version !== "string") continue;
+        if (!version.startsWith("workspace:")) continue;
+        issues.push(`${file.rel}: ${name}@${version}`);
+      }
+    }
+  }
+  return issues;
+};
+
+export const declaresDep = (
+  files: SourceFile[],
+  relPrefix: string,
+  name: string
+) => {
+  const docs = files.filter(file => file.rel.endsWith("package.json"));
+  for (const file of docs) {
+    const inApp = file.rel.startsWith(relPrefix);
+    const atRoot = file.rel === "package.json";
+    if (!inApp && !atRoot) continue;
+    if (file.body.includes(`"${name}"`)) return true;
+  }
+  return false;
+};
+
+export const importsLib = (body: string, lib: string) => {
+  if (body.includes(`"${lib}"`) || body.includes(`'${lib}'`)) return true;
+  if (body.includes(`"${lib}/`) || body.includes(`'${lib}/`)) return true;
+  return false;
+};

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

@@ -0,0 +1,182 @@
+import type { Locale } from "../../../core/i18n";
+import { translate } from "../../../core/i18n";
+import type { Output } from "../../../core/output";
+import type { Redactor } from "../../../core/redact";
+import { ADMIN_BINDINGS } from "./admin.flow";
+import type { CatalogCheck } from "./catalog";
+import { CHECKOUT_BINDINGS } from "./checkout.flow";
+import { CONTENT_BINDINGS } from "./content.flow";
+import { COPY } from "./copy";
+import { LOG_BINDINGS } from "./log.flow";
+import { listManifests, manifestProblem } from "./manifests";
+import { parseLegacyManifest } from "./manifests";
+import type { ManifestFile } from "./manifests";
+import { MEN_BINDINGS } from "./men.flow";
+import { OPS_BINDINGS } from "./ops.flow";
+import { ORD_BINDINGS } from "./ord.flow";
+import { ORDER_CHECK_ID, fixOrder, runOrder } from "./order";
+import { PAY_BINDINGS } from "./pay.flow";
+import { SDK_BINDINGS } from "./sdk.flow";
+import { STORE_BINDINGS } from "./store.flow";
+import type { YamlChannel } from "./yaml";
+
+export interface Outcome {
+  status: "pass" | "fail" | "skip";
+  detail?: string;
+}
+
+export interface RunCtx {
+  locale: Locale;
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  channels: YamlChannel[];
+  channelId?: string;
+  named: ReadonlySet<string>;
+  redactor: Redactor;
+}
+
+export interface CheckRun {
+  id: string;
+  outcome: Outcome;
+}
+
+const duplicate = (
+  seen: Map<string, string>,
+  id: string,
+  file: string,
+  locale: RunCtx["locale"]
+): Outcome | null => {
+  const previous = seen.get(id);
+  if (!previous) {
+    seen.set(id, file);
+    return null;
+  }
+  const vars = { id, left: previous, right: file };
+  const detail = translate(locale, COPY.duplicateId, vars);
+  return { status: "fail", detail };
+};
+
+const idOf = (file: ManifestFile): Outcome | string | null => {
+  if (file.kind === "json") {
+    const problem = manifestProblem(file.body);
+    if (problem) return { status: "fail", detail: `${file.file}: ${problem}` };
+    const json = JSON.parse(file.body) as { channel_id?: unknown };
+    return typeof json.channel_id === "string" ? json.channel_id : null;
+  }
+  const parsed = parseLegacyManifest(file.body);
+  if (!parsed) {
+    const detail = `${file.file}: channel-manifest.ts is not a channel`;
+    return { status: "fail", detail };
+  }
+  return parsed.channelId;
+};
+
+const runSdk11 = async (ctx: RunCtx): Promise<Outcome> => {
+  const files = await listManifests(ctx.cwd);
+  if (files.length === 0) {
+    return { status: "pass", detail: translate(ctx.locale, COPY.noManifests) };
+  }
+  const seen = new Map<string, string>();
+  for (const file of files) {
+    const id = idOf(file);
+    if (id && typeof id !== "string") return id;
+    if (typeof id !== "string") continue;
+    const clash = duplicate(seen, id, file.file, ctx.locale);
+    if (clash) return clash;
+  }
+  return { status: "pass" };
+};
+
+const fixSdk11 = async (ctx: RunCtx): Promise<Outcome> => {
+  const result = await runSdk11(ctx);
+  if (result.status !== "fail") return result;
+  const note = translate(ctx.locale, COPY.noSafeFix);
+  const detail = result.detail ? `${note} ${result.detail}` : note;
+  return { status: "fail", detail };
+};
+
+/** Script or Maestro binding. Unlisted ids stay unbound until a flow exists. */
+export interface CheckBinding {
+  kind: "script" | "maestro";
+  run: (ctx: RunCtx) => Promise<Outcome>;
+  fix?: (ctx: RunCtx) => Promise<Outcome>;
+}
+
+export const BINDINGS: Record<string, CheckBinding> = {
+  "SDK-11": { kind: "script", run: runSdk11, fix: fixSdk11 },
+  ...SDK_BINDINGS,
+  ...PAY_BINDINGS,
+  ...ORD_BINDINGS,
+  ...MEN_BINDINGS,
+  ...CHECKOUT_BINDINGS,
+  ...LOG_BINDINGS,
+  ...CONTENT_BINDINGS,
+  ...STORE_BINDINGS,
+  ...OPS_BINDINGS,
+  ...ADMIN_BINDINGS
+};
+
+export const runOne = async (
+  check: CatalogCheck,
+  ctx: RunCtx,
+  fix: boolean
+): Promise<Outcome> => {
+  if (check.id === "CLI-01") return { status: "pass" };
+  if (check.id === ORDER_CHECK_ID && !ctx.named.has(ORDER_CHECK_ID)) {
+    const detail = translate(ctx.locale, COPY.orderSkipped);
+    return { status: "skip", detail };
+  }
+  if (check.id === ORDER_CHECK_ID && fix) return fixOrder(ctx.locale);
+  if (check.id === ORDER_CHECK_ID) return runOrder(ctx);
+  const binding = BINDINGS[check.id];
+  if (!binding) {
+    return { status: "skip", detail: translate(ctx.locale, COPY.unbound) };
+  }
+  if (fix && check.fixable && binding.fix) return binding.fix(ctx);
+  return binding.run(ctx);
+};
+
+const jsonStatus = (status: Outcome["status"]) => {
+  if (status === "pass") return "passed";
+  if (status === "fail") return "failed";
+  return "skipped";
+};
+
+export const reportJson = (locale: Locale, runs: CheckRun[]) => {
+  const checks = runs.map(run => {
+    const status = jsonStatus(run.outcome.status);
+    if (run.outcome.status === "pass" && !run.outcome.detail) {
+      return { id: run.id, status };
+    }
+    return { id: run.id, status, reason: run.outcome.detail };
+  });
+  const passed = runs.filter(run => run.outcome.status === "pass").length;
+  const failed = runs.filter(run => run.outcome.status === "fail").length;
+  const skipped = runs.filter(run => run.outcome.status === "skip").length;
+  const totals = { passed, failed, skipped, total: runs.length };
+  return { locale, totals, groups: [{ id: "doctor", checks }] };
+};
+
+export const printRuns = (
+  output: Output,
+  locale: Locale,
+  runs: CheckRun[],
+  format: "text" | "json",
+  strict: boolean
+) => {
+  if (format === "json") {
+    output.line(JSON.stringify(reportJson(locale, runs), null, 2));
+  } else {
+    for (const run of runs) {
+      const detail = run.outcome.detail ? `  ${run.outcome.detail}` : "";
+      output.line(`${run.id}  ${run.outcome.status}${detail}`);
+    }
+  }
+  const failed = runs.some(run => run.outcome.status === "fail");
+  const skipped = runs.some(run => run.outcome.status === "skip");
+  if (strict && skipped) {
+    output.error(translate(locale, COPY.strictSkipped));
+  }
+  if (failed || (strict && skipped)) return 1;
+  return 0;
+};