create-geonosis 2.1.0 → 2.3.0

package/dist/{chunk-NLXNF4TP.js → chunk-UCGVZCVK.js}

@@ -24,13 +24,13 @@ var SEARCH = {
     "import { pgFtsSearchIndex, type SearchIndex, type SearchProjections } from '@geonosis/search'"
   ],
   name: "@geonosis/search",
-  version: "0.3.0"
+  version: "0.3.4"
 };
 var DOMAINS = [SEARCH];
 var DOMAIN_NAMES = DOMAINS.map((one) => one.field);
 var FOUNDATIONS = [
-  { at: "foundations/db", name: "@geonosis/db", version: "0.3.0" },
-  { at: "foundations/events", name: "@geonosis/events", version: "1.5.1" }
+  { at: "foundations/db", name: "@geonosis/db", version: "0.5.2" },
+  { at: "foundations/events", name: "@geonosis/events", version: "2.0.0" }
 ];
 var domainsNamed = (named) => named.map((one) => {
   const found = DOMAINS.find((domain) => domain.field === one);
@@ -116,17 +116,22 @@ import { basename, resolve } from "path";
 var RUNTIMES = ["bun", "pnpm"];
 var BACKENDS = ["medusa", "none", "sagaflow-cf"];
 var UIS = ["atoms-only", "none", "tiered-shadcn"];
+var MEDUSA_RANGE = "^2.19.0";
+var MEDUSA_PACKAGES = ["@medusajs/framework", "@medusajs/medusa"];
 var VALUED = /* @__PURE__ */ new Set([
   "--backend",
+  "--presets",
   "--brand",
   "--domains",
   "--kit",
   "--marketplace",
+  "--medusa",
   "--runtime",
   "--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;
@@ -186,6 +191,7 @@ var parseAnswers = (argv, cwd) => {
     domains,
     ...flags["--kit"] === void 0 ? {} : { kit: resolve(cwd, flags["--kit"]) },
     ...flags["--marketplace"] === void 0 ? {} : { marketplace: flags["--marketplace"] },
+    ...flags["--medusa"] === void 0 ? {} : { medusa: flags["--medusa"] },
     name,
     runtime: choose("--runtime", flags["--runtime"], RUNTIMES),
     scope: scopeOf(name),
@@ -372,6 +378,11 @@ var workspacesOf = (answers) => {
       dir: "packages/backend",
       mayDependOn: ["core"],
       name: `${scope}/backend`,
+      ...answers.backend === "medusa" ? {
+        packages: Object.fromEntries(
+          MEDUSA_PACKAGES.map((one) => [one, answers.medusa ?? MEDUSA_RANGE])
+        )
+      } : {},
       sources: {
         "src/handler.ts": HANDLER,
         "src/handler.test.ts": BACKEND_TEST,
@@ -397,7 +408,7 @@ var workspacesOf = (answers) => {
 
 // src/files.ts
 import { countersFor, LAW_SOURCE, rulesFor, tiersFor } from "@geonosis/cli";
-var VERSION = "2.1.0";
+var VERSION = "2.3.0";
 var SCHEMA = "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json";
 var CATALOG = {
   "@types/node": "^24.3.0",
@@ -435,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" ? {
@@ -497,9 +512,15 @@ var workspaceManifest = (workspace, answers, workspaces) => {
           return found === void 0 || found.name === workspace.name ? [] : [[found.name, "workspace:*"]];
         })
       ),
-      // With --kit the floors are linked from a workspace AFTER the install, and the manifest is
-      // rewritten to say so — the same reason the root's kit versions are left out.
-      ...answers.kit === void 0 ? workspace.packages : {}
+      // With --kit the FLOORS are linked from a workspace AFTER the install, and the manifest is
+      // rewritten to say so — the same reason the root's kit versions are left out. Everything else
+      // a workspace declares is third-party and stays: an engine dropped here is an engine the
+      // doctor cannot find, and a rule that presumes it then reads as a rule with no finding.
+      ...Object.fromEntries(
+        Object.entries(workspace.packages ?? {}).filter(
+          ([name]) => answers.kit === void 0 || !name.startsWith("@geonosis/")
+        )
+      )
     }
   });
 };
@@ -519,8 +540,47 @@ var GRAPH_SYNCS = [
 var graphScript = GRAPH_SYNCS.map(
   ({ target, write: write2 }) => `geonosis-ledger sync --target ${target} --write ${write2}`
 ).join(" && ");
+var HOOK_INSTALLER = "scripts/install-hooks.mjs";
+var hookInstaller = () => [
+  "import { spawnSync } from 'node:child_process'",
+  "import { existsSync, lstatSync } from 'node:fs'",
+  "import { join, resolve } from 'node:path'",
+  "",
+  "const git = (...args) => {",
+  "  const done = spawnSync('git', args, { encoding: 'utf8' })",
+  "",
+  "  return done.status === 0 ? done.stdout.trim() : undefined",
+  "}",
+  "",
+  "const say = (line) => process.stdout.write(`install-hooks: ${line}\n`)",
+  "",
+  "const common = git('rev-parse', '--path-format=absolute', '--git-common-dir')",
+  "if (common === undefined) {",
+  "  say('git says nothing about this directory, so there is no hooks path to install into.')",
+  "  process.exit(0)",
+  "}",
+  "",
+  "// A worktree's own .git is a FILE; the hooks it would install into belong to the checkout the",
+  "// common dir names, and writing them from here changes the tree somebody else is in.",
+  "const here = resolve(process.cwd(), '.git')",
+  "if (existsSync(here) && lstatSync(here).isFile() && resolve(common) !== here) {",
+  "  say(`this is a git worktree and its hooks path is shared with ${common} \u2014 install them there instead.`)",
+  "  process.exit(0)",
+  "}",
+  "",
+  "const lefthook = join(process.cwd(), 'node_modules/.bin/lefthook')",
+  "if (!existsSync(lefthook)) {",
+  "  say('lefthook is not installed here yet, so no hook was written.')",
+  "  process.exit(0)",
+  "}",
+  "",
+  "const done = spawnSync(lefthook, ['install'], { stdio: 'inherit' })",
+  "process.exit(done.status ?? 0)",
+  ""
+].join("\n");
 var rootScripts = ({ runtime }) => ({
   doctor: "geonosis-doctor",
+  prepare: `node ${HOOK_INSTALLER}`,
   "format:check": "oxfmt --config .oxfmtrc.json --check .",
   format: "oxfmt --config .oxfmtrc.json .",
   lint: "oxlint --config .oxlintrc.json .",
@@ -732,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),
@@ -809,6 +873,7 @@ var filesFor = (answers) => {
       )
     ),
     "skills-lock.json": json({ skills: {}, version: 1 }),
+    [HOOK_INSTALLER]: hookInstaller(),
     "lefthook.yml": [
       "# Staged scope only, so a commit never waits on a file it did not touch. When one fires, fix",
       "# or delete the code \u2014 never downgrade the rule to get past it.",
@@ -1084,6 +1149,8 @@ export {
   RUNTIMES,
   BACKENDS,
   UIS,
+  MEDUSA_RANGE,
+  parseArgs,
   parseAnswers,
   wantsInstall,
   CORPUS_DIR,

package/dist/create-geonosis-cli.js

@@ -1,19 +1,198 @@
 import {
+  BACKENDS,
   DOMAIN_NAMES,
+  MEDUSA_RANGE,
   PLATFORM_FILE,
+  UIS,
   checkScaffold,
   describeDrift,
   finish,
   parseAnswers,
+  parseArgs,
   wantsInstall,
   writeScaffold
-} from "./chunk-NLXNF4TP.js";
+} from "./chunk-UCGVZCVK.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,
@@ -27,10 +206,21 @@ default borrowed from another repo would be that repo's stack hardcoded into thi
   --domains      the domains this repo composes \u2014 ${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>
+                 the Medusa a --backend medusa tree declares. Defaults to ${MEDUSA_RANGE}, the version
+                 the one Medusa consumer of this kit runs (measured 2026-09-02): the Medusa rules
+                 the scaffold turns on presume the engine, and a tree that enables them while
+                 declaring no @medusajs/* earns nine doctor WARNs for rules with no finding.
   --kit <path>   read the kit from a workspace instead of the registry. A proof aid: it symlinks the
                  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
@@ -57,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.d.ts

@@ -13,6 +13,8 @@ type Answers = {
     /** The kit read from a workspace instead of the registry — a proof aid, never the default. */
     kit?: string;
     marketplace?: string;
+    /** The Medusa range a `--backend medusa` tree declares. `MEDUSA_RANGE` unless one is named. */
+    medusa?: string;
     name: string;
     runtime: Runtime;
     scope: string;

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-geonosis",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "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.1.0"
+    "@geonosis/cli": "2.3.0"
   },
   "engines": {
     "node": ">=22"