create-geonosis 2.2.0 → 2.3.1

package/dist/{chunk-IQS75GD7.js → chunk-CT3CTASI.js}

@@ -24,13 +24,13 @@ var SEARCH = {
     "import { pgFtsSearchIndex, type SearchIndex, type SearchProjections } from '@geonosis/search'"
   ],
   name: "@geonosis/search",
-  version: "0.3.3"
+  version: "0.3.5"
 };
 var DOMAINS = [SEARCH];
 var DOMAIN_NAMES = DOMAINS.map((one) => one.field);
 var FOUNDATIONS = [
-  { at: "foundations/db", name: "@geonosis/db", version: "0.5.1" },
-  { at: "foundations/events", name: "@geonosis/events", version: "1.5.2" }
+  { at: "foundations/db", name: "@geonosis/db", version: "0.6.0" },
+  { at: "foundations/events", name: "@geonosis/events", version: "2.1.0" }
 ];
 var domainsNamed = (named) => named.map((one) => {
   const found = DOMAINS.find((domain) => domain.field === one);
@@ -120,6 +120,7 @@ var MEDUSA_RANGE = "^2.19.0";
 var MEDUSA_PACKAGES = ["@medusajs/framework", "@medusajs/medusa"];
 var VALUED = /* @__PURE__ */ new Set([
   "--backend",
+  "--presets",
   "--brand",
   "--domains",
   "--kit",
@@ -129,7 +130,8 @@ var VALUED = /* @__PURE__ */ new Set([
   "--themekit",
   "--ui"
 ]);
-var SWITCHES = /* @__PURE__ */ new Set(["--check", "--help", "-h", "--no-install"]);
+var SWITCHES = /* @__PURE__ */ new Set(["--check", "--help", "-h", "--no-install", "--plan"]);
+var parseArgs = (argv) => read(argv);
 var read = (argv) => {
   const flags = {};
   let dir;
@@ -406,7 +408,7 @@ var workspacesOf = (answers) => {
 
 // src/files.ts
 import { countersFor, LAW_SOURCE, rulesFor, tiersFor } from "@geonosis/cli";
-var VERSION = "2.2.0";
+var VERSION = "2.3.1";
 var SCHEMA = "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json";
 var CATALOG = {
   "@types/node": "^24.3.0",
@@ -444,6 +446,10 @@ var answersForRules = (answers) => ({
     "no-raw-html-atoms": [
       "error",
       [{ atom: "Button", element: "button", importPath: `${answers.scope}/ui/atoms/button` }]
+    ],
+    "no-runtime-dead-affordance": [
+      "error",
+      [{ atom: "Button", element: "button", importPath: `${answers.scope}/ui/atoms/button` }]
     ]
   },
   ...answers.backend === "medusa" ? {
@@ -786,7 +792,11 @@ var tsconfigBase = (answers) => json({
 });
 var filesFor = (answers) => {
   const workspaces = workspacesOf(answers);
-  const counters = countersFor(answers.runtime, LAW_SOURCE);
+  const counters = countersFor(
+    answers.runtime,
+    LAW_SOURCE,
+    workspaces.map((one) => ({ dir: one.dir, name: one.name }))
+  );
   const { rules } = rulesFor(presetsFor(answers), answersForRules(answers));
   const files = {
     "package.json": rootManifest(answers),
@@ -1140,6 +1150,7 @@ export {
   BACKENDS,
   UIS,
   MEDUSA_RANGE,
+  parseArgs,
   parseAnswers,
   wantsInstall,
   CORPUS_DIR,

package/dist/create-geonosis-cli.js

@@ -1,21 +1,198 @@
 import {
+  BACKENDS,
   DOMAIN_NAMES,
   MEDUSA_RANGE,
   PLATFORM_FILE,
+  UIS,
   checkScaffold,
   describeDrift,
   finish,
   parseAnswers,
+  parseArgs,
   wantsInstall,
   writeScaffold
-} from "./chunk-IQS75GD7.js";
+} from "./chunk-CT3CTASI.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: `@${basename(at).toLowerCase()}`,
+    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: [.../* @__PURE__ */ new Set([...KIT_OWNED_BLOCKS, ...Object.keys(config)])].filter((block) => KIT_OWNED_BLOCKS.includes(block)).toSorted().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 "fs";
 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]
 
 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,
@@ -38,6 +215,12 @@ default borrowed from another repo would be that repo's stack hardcoded into thi
                  packages after the install and rewrites the manifest to say so.
   --no-install   write the files and stop. The gates cannot run until the two "geonosis sync
                  --target" commands below have been run, and they are printed for you.
+  --plan         what ADOPTING an existing repo would take, computed off its tree and written
+                 nowhere: the files and keys it lacks of what the scaffold writes, the rules each
+                 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.
   --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
@@ -64,9 +247,26 @@ var main = () => {
 `);
     return argv.length === 0 ? 2 : 0;
   }
+  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"] }
+        })
+      )}
+`
+    );
+    return 0;
+  }
   const answers = parseAnswers(argv, process.cwd());
   if (argv.includes("--check")) {
-    if (!existsSync(answers.dir)) {
+    if (!existsSync2(answers.dir)) {
       throw new Error(`${answers.dir} is not there \u2014 --check reads a repo, it never makes one`);
     }
     const drift = checkScaffold(answers);

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   wantsInstall,
   workspacesOf,
   writeScaffold
-} from "./chunk-IQS75GD7.js";
+} from "./chunk-CT3CTASI.js";
 export {
   BACKENDS,
   CORPUS_DIR,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-geonosis",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "types": "./dist/index.d.ts",
   "description": "Scaffold a microcompany repo that passes its own geonosis gates on day one.",
   "keywords": [
@@ -34,7 +34,7 @@
     "dist"
   ],
   "dependencies": {
-    "@geonosis/cli": "2.2.0"
+    "@geonosis/cli": "2.3.1"
   },
   "engines": {
     "node": ">=22"