create-geonosis 2.13.0 → 3.0.0

package/dist/create-geonosis-cli.js

@@ -1,199 +1,15 @@
-import {
-  BACKENDS,
-  DOMAIN_NAMES,
-  MEDUSA_RANGE,
-  PLATFORM_FILE,
-  UIS,
-  checkScaffold,
-  describeDrift,
-  finish,
-  parseAnswers,
-  parseArgs,
-  scopeOf,
-  wantsInstall,
-  writeScaffold
-} from "./chunk-LUUI74BB.js";
-
-// src/create-geonosis-cli.ts
-import { existsSync as existsSync2 } from "fs";
-
-// src/adopt.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { basename, join, resolve } from "path";
-import { countersFor, rulesFor, runtimeOf, tiersFor } from "@geonosis/cli";
-var ADOPT_USAGE = "create-geonosis --plan <dir> [--presets <a,b>] [--runtime pnpm|bun] [--backend medusa|sagaflow-cf|none] [--ui tiered-shadcn|atoms-only|none] \u2014 what adopting this repo would take, computed off the tree. Writes nothing.";
-var LOCKFILES = ["bun.lock", "bun.lockb", "pnpm-lock.yaml"];
-var MEDUSA = "@medusajs/";
-var WORKERS = ["wrangler", "@cloudflare/workers-types", "sagaflow-js"];
-var readJson = (at) => {
-  if (!existsSync(at)) return void 0;
-  try {
-    return JSON.parse(readFileSync(at, "utf8"));
-  } catch {
-    return void 0;
-  }
-};
-var manifestsIn = (dir) => {
-  const found = [readJson(join(dir, "package.json"))];
-  for (const group of ["apps", "packages"]) {
-    const at = join(dir, group);
-    if (!existsSync(at)) continue;
-    for (const entry of readdirSync(at, { withFileTypes: true })) {
-      if (entry.isDirectory()) found.push(readJson(join(at, entry.name, "package.json")));
-    }
-  }
-  return found.filter((one) => one !== void 0);
-};
-var dependencyNames = (manifests) => manifests.flatMap((one) => [
-  ...Object.keys(one.dependencies ?? {}),
-  ...Object.keys(one.devDependencies ?? {})
-]);
-var backendOf = (manifests) => {
-  const names = dependencyNames(manifests);
-  if (names.some((one) => one.startsWith(MEDUSA))) return "medusa";
-  if (names.some((one) => WORKERS.includes(one))) return "sagaflow-cf";
-  return "none";
-};
-var chosen = (flag, given, allowed) => {
-  if (given === void 0) return void 0;
-  if (!allowed.includes(given)) {
-    throw new Error(`${flag} "${given}" is not one of ${allowed.join(", ")}`);
-  }
-  return given;
-};
-var uiOf = (dir, given) => {
-  if (given !== void 0) return given;
-  if (!existsSync(join(dir, "packages/ui"))) return "none";
-  throw new Error(
-    `${dir} has a packages/ui and no --ui was given \u2014 the tier decides which rules the plan proposes, and a directory listing cannot say which tier it is. Name --ui ${UIS.join("|")}.`
-  );
-};
-var doorFor = (block) => `@geonosis/${block}`;
-var KIT_OWNED_BLOCKS = ["ledger", "review", "testbed", "verify", "walk"];
-var planAdoption = ({ backend, dir, presets, runtime, ui }) => {
-  const at = resolve(dir);
-  if (!existsSync(at))
-    throw new Error(`${at} is not there \u2014 --plan reads a repo, it never makes one`);
-  const manifests = manifestsIn(at);
-  const chosenRuntime = chosen("--runtime", runtime, ["bun", "pnpm"]) ?? runtimeOf(at);
-  if (chosenRuntime === void 0) {
-    throw new Error(
-      `${at} has none of ${LOCKFILES.join(", ")}, so nothing there says which package manager it runs \u2014 name --runtime pnpm|bun.`
-    );
-  }
-  const answers = {
-    backend: chosen("--backend", backend, BACKENDS) ?? backendOf(manifests),
-    dir: at,
-    domains: [],
-    name: basename(at),
-    runtime: chosenRuntime,
-    scope: scopeOf(basename(at)),
-    ui: uiOf(at, chosen("--ui", ui, UIS))
-  };
-  const drift = checkScaffold(answers);
-  const enabled = new Set(
-    Object.keys(
-      readJson(join(at, ".oxlintrc.json"))?.rules ?? {}
-    )
-  );
-  const config = readJson(join(at, "geonosis.json")) ?? {};
-  const declaredTiers = config["verify"] ?? {};
-  const declaredCounters = new Set(
-    (readJson(
-      join(at, "geonosis.ratchet.json")
-    )?.counters ?? []).map((one) => one.key ?? one.counter ?? "")
-  );
-  const declaredPackages = new Set(dependencyNames(manifests));
-  const { unanswered } = rulesFor(presets);
-  const tiers = tiersFor({
-    rules: {},
-    runtime: chosenRuntime,
-    scripts: Object.keys(
-      readJson(join(at, "package.json"))?.scripts ?? {}
-    )
-  });
-  return {
-    backend: answers.backend,
-    counters: countersFor(chosenRuntime, "LAW.md").map((one) => {
-      const key = typeof one["key"] === "string" ? one["key"] : String(one["counter"]);
-      return { declared: declaredCounters.has(key), key };
-    }),
-    dir: at,
-    doors: KIT_OWNED_BLOCKS.map((block) => ({
-      block,
-      declared: declaredPackages.has(doorFor(block)),
-      package: doorFor(block)
-    })),
-    files: drift.filter((one) => one.kind === "missing"),
-    keys: drift.filter((one) => one.kind === "key"),
-    presets: presets.map((name) => {
-      const brings = Object.keys(rulesFor([name]).rules);
-      return {
-        brings: brings.length,
-        enabled: brings.filter((id) => enabled.has(id)),
-        name
-      };
-    }),
-    runtime: chosenRuntime,
-    tiers: Object.entries(tiers).map(([name, steps]) => ({
-      declared: Object.hasOwn(declaredTiers, name),
-      name,
-      steps
-    })),
-    ui: answers.ui,
-    unanswered,
-    unreadable: drift.filter((one) => one.kind === "unreadable")
-  };
-};
-var section = (title, lines) => lines.length === 0 ? [`${title} \u2014 none`, ""] : [`${title} (${lines.length})`, ...lines, ""];
-var formatPlan = (plan) => [
-  `adoption plan for ${plan.dir}`,
-  `  runtime ${plan.runtime} \xB7 backend ${plan.backend} \xB7 ui ${plan.ui}`,
-  "",
-  ...section(
-    "FILES the scaffold writes and this repo has none of",
-    plan.files.map((one) => `  ${one.file}`)
-  ),
-  ...section(
-    "KEYS the scaffold declares inside a file this repo has",
-    plan.keys.map((one) => `  ${one.file} \u2192 ${one.at}`)
-  ),
-  ...section(
-    "RULES the presets bring",
-    plan.presets.map(
-      (one) => `  ${one.name}: ${one.brings} rules, ${one.enabled.length} already enabled here`
-    )
-  ),
-  ...section(
-    "RULES left out until somebody answers their option",
-    plan.unanswered.map(([rule, option]) => `  ${rule} needs \`${option}\``)
-  ),
-  ...section(
-    "COUNTERS the ratchet would run",
-    plan.counters.map((one) => `  ${one.key}${one.declared ? " \u2014 declared" : ""}`)
-  ),
-  ...section(
-    "TIERS",
-    plan.tiers.map((one) => `  ${one.name}${one.declared ? " \u2014 declared" : ""}`)
-  ),
-  ...section(
-    "DOORS a block needs declared",
-    plan.doors.map(
-      (one) => `  ${one.package} for "${one.block}"${one.declared ? " \u2014 declared" : ""}`
-    )
-  ),
-  ...plan.unreadable.length === 0 ? [] : section(
-    "FILES this check could not read as JSON",
-    plan.unreadable.map((one) => `  ${one.file}`)
-  )
-].join("\n");
-
 // src/create-geonosis-cli.ts
+import { existsSync } from "node:fs";
+import { ADOPT_USAGE, formatPlan, planAdoption } from "./adopt.js";
+import { MEDUSA_RANGE, parseAnswers, parseArgs, wantsInstall } from "./answers.js";
+import { checkScaffold, describeDrift } from "./check.js";
+import { DOMAIN_NAMES, PLATFORM_FILE } from "./composition.js";
+import { finish, writeScaffold } from "./scaffold.js";
 var USAGE = `create-geonosis <dir> --runtime pnpm|bun --backend medusa|sagaflow-cf|none --ui tiered-shadcn|atoms-only|none
                 [--medusa <range>]
                 [--domains <a,b>] [--brand <name>] [--themekit <name>] [--marketplace <path>] [--kit <path>] [--no-install]
                 [--check]
-create-geonosis --plan <dir> [--presets <a,b>] [--runtime \u2026] [--backend \u2026] [--ui \u2026]
+create-geonosis --plan <dir> [--presets <a,b>] [--runtime …] [--backend …] [--ui …]
 
 Writes a repo that passes its own gates on day one: a workspace with one catalog of shared versions,
 an exports map and no barrel in every package, typecheck + lint + test scripts in every workspace,
@@ -204,7 +20,7 @@ skills lock, and a reach corpus in this repo's own vocabulary so the doctor can
 There is no default for --runtime, --backend or --ui. Each one decides the shape of the tree, and a
 default borrowed from another repo would be that repo's stack hardcoded into this one.
 
-  --domains      the domains this repo composes \u2014 ${DOMAIN_NAMES.join(", ")}. Each one writes its
+  --domains      the domains this repo composes — ${DOMAIN_NAMES.join(", ")}. Each one writes its
                  store into the app's ${PLATFORM_FILE}: the composition root, in two lifetimes, with
                  the tenant session opened before any store is built. A name nothing ships is refused.
   --medusa <range>
@@ -221,19 +37,19 @@ default borrowed from another repo would be that repo's stack hardcoded into thi
                  preset brings against the ones already enabled, the rules left out until somebody
                  answers their option, the counters, the tiers and the doors a block needs
                  declared. The runtime and the backend are read off the lockfile and the manifests;
-                 a flag overrides one. Exit 0 \u2014 it is a report.
+                 a flag overrides one. Exit 0 — it is a report.
   --check        say what an EXISTING repo is missing of what the scaffold writes today, and WRITE
                  NOTHING. Files it has never had, and keys inside the JSON it has. Contents and
                  values are never compared: a repo that has been worked in has rewritten them, and
                  it was entitled to. Exit 1 when anything drifted.
 
-Exit: 0 written (or, under --check, no drift) \xB7 1 refused (a directory with something in it, an
-answer that is not one) or drift found \xB7 2 a run that could not be made at all.`;
+Exit: 0 written (or, under --check, no drift) · 1 refused (a directory with something in it, an
+answer that is not one) or drift found · 2 a run that could not be made at all.`;
 var CONFIG_SHAPE = `create-geonosis reads no configuration file.
 
 It WRITES them: geonosis.json, .oxlintrc.json, geonosis.ratchet.json and gate-baseline.json, from
 the answers given on the command line. Every answer is a flag, and there is no default for the three
-that decide the shape of the tree \u2014 see create-geonosis --help.
+that decide the shape of the tree — see create-geonosis --help.
 
 For the shape of what it wrote, ask the bin that reads it: geonosis-<tool> --print-config-shape.`;
 var main = () => {
@@ -250,61 +66,57 @@ var main = () => {
   }
   if (argv.includes("--plan")) {
     const { dir, flags } = parseArgs(argv);
-    if (dir === void 0) throw new Error(`--plan needs a directory \u2014 ${ADOPT_USAGE}`);
-    process.stdout.write(
-      `${formatPlan(
-        planAdoption({
-          ...flags["--backend"] === void 0 ? {} : { backend: flags["--backend"] },
-          dir,
-          presets: (flags["--presets"] ?? "frontend,tooling").split(",").map((one) => one.trim()).filter((one) => one !== ""),
-          ...flags["--runtime"] === void 0 ? {} : { runtime: flags["--runtime"] },
-          ...flags["--ui"] === void 0 ? {} : { ui: flags["--ui"] }
-        })
-      )}
-`
-    );
+    if (dir === undefined)
+      throw new Error(`--plan needs a directory — ${ADOPT_USAGE}`);
+    process.stdout.write(`${formatPlan(planAdoption({
+      ...flags["--backend"] === undefined ? {} : { backend: flags["--backend"] },
+      dir,
+      presets: (flags["--presets"] ?? "frontend,tooling").split(",").map((one) => one.trim()).filter((one) => one !== ""),
+      ...flags["--runtime"] === undefined ? {} : { runtime: flags["--runtime"] },
+      ...flags["--ui"] === undefined ? {} : { ui: flags["--ui"] }
+    }))}
+`);
     return 0;
   }
   const answers = parseAnswers(argv, process.cwd());
   if (argv.includes("--check")) {
-    if (!existsSync2(answers.dir)) {
-      throw new Error(`${answers.dir} is not there \u2014 --check reads a repo, it never makes one`);
+    if (!existsSync(answers.dir)) {
+      throw new Error(`${answers.dir} is not there — --check reads a repo, it never makes one`);
     }
     const drift = checkScaffold(answers);
     if (drift.length === 0) {
-      process.stdout.write(`create-geonosis --check ${answers.dir} \u2014 no drift
+      process.stdout.write(`create-geonosis --check ${answers.dir} — no drift
 `);
       return 0;
     }
-    for (const line of describeDrift(drift)) process.stderr.write(`  ${line}
+    for (const line of describeDrift(drift))
+      process.stderr.write(`  ${line}
+`);
+    process.stderr.write(`create-geonosis --check ${answers.dir} — ${drift.length} drift, nothing written
 `);
-    process.stderr.write(
-      `create-geonosis --check ${answers.dir} \u2014 ${drift.length} drift, nothing written
-`
-    );
     return 1;
   }
   const written = writeScaffold(answers);
-  process.stdout.write(`create-geonosis \u2014 ${written.length} file(s) into ${answers.dir}
+  process.stdout.write(`create-geonosis — ${written.length} file(s) into ${answers.dir}
 `);
   const install = wantsInstall(argv);
   for (const step of finish({ answers, install })) {
     process.stdout.write(`  ${step.code === 0 ? "ok  " : "FAIL"}  ${step.what}
 `);
-    if (step.code !== 0) process.stdout.write(`${step.output}
+    if (step.code !== 0)
+      process.stdout.write(`${step.output}
 `);
   }
   if (!install) {
-    process.stdout.write(
-      [
-        "",
-        "  Nothing was installed, so the edges table has not reached the gates yet. Run:",
-        `    cd ${answers.dir} && ${answers.runtime} install`,
-        "    geonosis sync --target turbo --into turbo.json",
-        "    geonosis sync --target layer-walls --into .oxlintrc.json",
-        ""
-      ].join("\n")
-    );
+    process.stdout.write([
+      "",
+      "  Nothing was installed, so the edges table has not reached the gates yet. Run:",
+      `    cd ${answers.dir} && ${answers.runtime} install`,
+      "    geonosis sync --target turbo --into turbo.json",
+      "    geonosis sync --target layer-walls --into .oxlintrc.json",
+      ""
+    ].join(`
+`));
   }
   return 0;
 };

package/dist/files.d.ts

@@ -0,0 +1,18 @@
+import type { Answers } from './answers.js';
+declare const presetsFor: (answers: Answers) => string[];
+/** The kit a scaffolded repo runs on, at the version this scaffold was published at. */
+export declare const kitDependencies: (answers: Answers) => Record<string, string>;
+/**
+ * The two files the edges table generates, named once. `scaffold` runs them when it makes the tree
+ * and the `sync:graph` script runs them when the table changes; a second spelling of the pair is a
+ * second answer to where the graph comes from.
+ */
+export declare const GRAPH_SYNCS: {
+    target: string;
+    write: string;
+}[];
+/** What the root can be asked to run — and therefore what a verify tier may name (`tiersFor`). */
+export declare const HOOK_INSTALLER = "scripts/install-hooks.mjs";
+export declare const filesFor: (answers: Answers) => Record<string, string>;
+export declare const presetsChosenBy: typeof presetsFor;
+export {};