create-macostack 0.2.1 → 0.4.0

package/bin/create-macostack.ts

@@ -6,6 +6,7 @@ import {
     multiselect,
     note,
     outro,
+    select,
     spinner,
     text,
 } from "@clack/prompts";
@@ -17,7 +18,7 @@ import {
     rmSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 
 // create-macostack — start a new app from the macostack templates.
@@ -44,6 +45,24 @@ type Part = {
     hint: string;
 };
 
+// The module question a template exposes via `setup --questions`. The CLI stays
+// dumb: it renders whatever the template declares (options + optional one-line
+// descriptions), never hardcoding which modules exist.
+type ModuleSpec = {
+    options: string[];
+    initial: string[];
+    descriptions?: Record<string, string>;
+    exclusive?: string[][];
+};
+
+// Optional deploy-target question a template may expose (e.g. vps vs cloudflare
+// workers). Same dumb-CLI contract as modules: rendered from what setup declares.
+type RuntimeSpec = {
+    options: string[];
+    initial: string;
+    descriptions?: Record<string, string>;
+};
+
 const PARTS: Part[] = [
     {
         id: "server",
@@ -88,6 +107,7 @@ if (flags.help) {
 
 Usage:
   bun create macostack <app-name>
+  bun create macostack .            scaffold into the current (empty) folder
 
 Flags:
   --server / --client   scaffold only that part (default: it asks)
@@ -139,13 +159,33 @@ const isEmptyDir = (dir: string) =>
 // WIZARD
 //////////////////////////////////////////////////////////////////
 
+const BLUE = "\x1b[38;5;33m";
+const RESET = "\x1b[0m";
+console.log(`${BLUE}
+███    ███  █████   ██████  ██████  ███████ ████████  █████   ██████ ██   ██
+████  ████ ██   ██ ██      ██    ██ ██         ██    ██   ██ ██      ██  ██
+██ ████ ██ ███████ ██      ██    ██ ███████    ██    ███████ ██      █████
+██  ██  ██ ██   ██ ██      ██    ██      ██    ██    ██   ██ ██      ██  ██
+██      ██ ██   ██  ██████  ██████  ███████    ██    ██   ██  ██████ ██   ██
+${RESET}`);
+
 intro("create-macostack");
 
 // 1. App name (positional arg or prompt).
 const positional = parsed.positionals[0];
 const validName = (v: string) => /^[a-z0-9][a-z0-9-]*$/.test(v);
 let appName: string;
-if (positional) {
+// `.` means "right here": the current folder is the app, its name is the name.
+const scaffoldHere = positional === "." || positional === "./";
+if (scaffoldHere) {
+    appName = basename(process.cwd());
+    if (!validName(appName)) {
+        bail(
+            `This folder is called "${appName}" — app names use lowercase letters, digits and dashes.\n` +
+                "   Rename the folder, or run me with an explicit name: bun create macostack my-app",
+        );
+    }
+} else if (positional) {
     if (!validName(positional)) {
         bail("App names use lowercase letters, digits and dashes — e.g. soccer-app");
     }
@@ -164,27 +204,122 @@ if (positional) {
     );
 }
 
-const targetRoot = resolve(process.cwd(), appName);
-if (!isEmptyDir(targetRoot)) {
-    bail(`The folder ./${appName} already exists and isn't empty — pick another name or clear it first.`);
+const targetRoot = scaffoldHere ? process.cwd() : resolve(process.cwd(), appName);
+// How we refer to the app folder in messages: "cd ./server" when scaffolding
+// in place, "cd my-app/server" otherwise.
+const displayRoot = scaffoldHere ? "." : appName;
+
+//////////////////////////////////////////////////////////////////
+// ALREADY SET UP? → manage instead of scaffold
+//////////////////////////////////////////////////////////////////
+
+// Toggle a part's modules by talking to ITS setup (--questions → choices →
+// per-module `bun run module on/off`). Used when macostack already lives here.
+const adjustModules = async (part: Part) => {
+    const dir = resolve(targetRoot, part.folder);
+    const q = Bun.spawnSync(["bun", "run", "setup", "--questions"], {
+        cwd: dir,
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    let spec: { modules?: ModuleSpec } | null = null;
+    if (q.exitCode === 0) {
+        try {
+            spec = JSON.parse(q.stdout.toString().trim().split("\n").at(-1) ?? "");
+        } catch {}
+    }
+    const mods = spec?.modules;
+    if (!mods) {
+        note(`This ${part.label.toLowerCase()} doesn't expose adjustable modules.`, part.label);
+        return;
+    }
+
+    let chosen: string[];
+    for (;;) {
+        chosen = answered(
+            await multiselect({
+                message: `${part.label} — which modules should be ON? (your current setup is preselected)`,
+                options: mods.options.map((m) => ({ value: m, label: m, hint: mods.descriptions?.[m] })),
+                initialValues: mods.initial,
+                required: false,
+            }),
+        );
+        const clash = (mods.exclusive ?? []).find((pair) => pair.every((m) => chosen.includes(m)));
+        if (!clash) break;
+        note(`${clash.join(" and ")} can't both be on — keep one of the two.`, "One thing");
+    }
+
+    const turnOn = chosen.filter((m) => !mods.initial.includes(m));
+    const turnOff = mods.initial.filter((m) => !chosen.includes(m));
+    if (turnOn.length === 0 && turnOff.length === 0) {
+        note("No changes — everything stays exactly as it was.", part.label);
+        return;
+    }
+    const s = spinner();
+    s.start(`${part.label} — applying your changes`);
+    for (const m of turnOn) Bun.spawnSync(["bun", "run", "module", m, "on"], { cwd: dir, stdout: "pipe", stderr: "pipe" });
+    for (const m of turnOff) Bun.spawnSync(["bun", "run", "module", m, "off"], { cwd: dir, stdout: "pipe", stderr: "pipe" });
+    const changes = [...turnOn.map((m) => `${m} → on`), ...turnOff.map((m) => `${m} → off`)];
+    s.stop(`${part.label} — updated: ${changes.join(", ")}`);
+};
+
+const present = PARTS.filter((p) => existsSync(resolve(targetRoot, p.folder, "package.json")));
+let selected: Part[] | null = null;
+
+if (present.length > 0) {
+    if (flags.yes) {
+        bail(`${displayRoot} already has macostack in it — run me without --yes to manage it.`);
+    }
+    const missing = PARTS.filter((p) => !present.includes(p));
+    const stateLine = PARTS.map((p) => `${p.label}: ${present.includes(p) ? "✓ installed" : "— not yet"}`).join("   ");
+    note(stateLine, "You already have macostack here");
+
+    const actions = [
+        ...missing.map((p) => ({ value: `add:${p.id}`, label: `Add the ${p.label.toLowerCase()}`, hint: p.hint })),
+        ...present.map((p) => ({ value: `adjust:${p.id}`, label: `Adjust ${p.label.toLowerCase()} modules`, hint: "turn things on or off" })),
+        { value: "exit", label: "Nothing — just looking", hint: "leaves everything untouched" },
+    ];
+    const action = answered(
+        await select({ message: "What would you like to do?", options: actions }),
+    );
+
+    if (action === "exit") {
+        outro("All good — nothing was touched. 👋");
+        process.exit(0);
+    }
+    const [verb, partId] = (action as string).split(":");
+    const part = PARTS.find((p) => p.id === partId)!;
+    if (verb === "adjust") {
+        await adjustModules(part);
+        outro(`${appName} is up to date ✨`);
+        process.exit(0);
+    }
+    selected = [part]; // "add:" → scaffold just the missing part below
+} else if (!isEmptyDir(targetRoot)) {
+    bail(
+        scaffoldHere
+            ? "This folder isn't empty — I only scaffold into a clean one."
+            : `The folder ./${appName} already exists and isn't empty — pick another name or clear it first.`,
+    );
 }
 
 // 2. Which parts?
-let selected: Part[];
-if (flags.server || flags.client) {
-    selected = PARTS.filter((p) => flags[p.id]);
-} else if (flags.yes) {
-    selected = PARTS;
-} else {
-    const picked = answered(
-        await multiselect({
-            message: `What does ${appName} need? (space to pick, enter to continue)`,
-            options: PARTS.map((p) => ({ value: p.id, label: p.label, hint: p.hint })),
-            initialValues: PARTS.map((p) => p.id),
-            required: true,
-        }),
-    );
-    selected = PARTS.filter((p) => picked.includes(p.id));
+if (!selected) {
+    if (flags.server || flags.client) {
+        selected = PARTS.filter((p) => flags[p.id]);
+    } else if (flags.yes) {
+        selected = PARTS;
+    } else {
+        const picked = answered(
+            await multiselect({
+                message: `What does ${appName} need? (space to pick, enter to continue)`,
+                options: PARTS.map((p) => ({ value: p.id, label: p.label, hint: p.hint })),
+                initialValues: PARTS.map((p) => p.id),
+                required: true,
+            }),
+        );
+        selected = PARTS.filter((p) => picked.includes(p.id));
+    }
 }
 
 // 3. GitHub access — checked before anything is created.
@@ -259,7 +394,7 @@ for (const p of selected) {
     } finally {
         rmSync(tmp, { recursive: true, force: true });
     }
-    s.stop(`${p.label} — downloaded into ${appName}/${p.folder}`);
+    s.stop(`${p.label} — downloaded into ${displayRoot}/${p.folder}`);
 
     if (!flags["skip-install"]) {
         const s2 = spinner();
@@ -268,7 +403,7 @@ for (const p of selected) {
         s2.stop(
             code === 0
                 ? `${p.label} — dependencies installed`
-                : `${p.label} — bun install had issues (run it again inside ${appName}/${p.folder})`,
+                : `${p.label} — bun install had issues (run it again inside ${displayRoot}/${p.folder})`,
         );
     }
 
@@ -280,7 +415,7 @@ for (const p of selected) {
         ? await Bun.file(resolve(dest, "package.json")).json()
         : null;
     if (!flags["skip-setup"] && pkg?.scripts?.setup) {
-        let questions: { modules?: { options: string[]; initial: string[]; exclusive?: string[][] } } | null = null;
+        let questions: { modules?: ModuleSpec; runtime?: RuntimeSpec } | null = null;
         if (!flags.yes) {
             const q = Bun.spawnSync(["bun", "run", "setup", "--questions"], {
                 cwd: dest,
@@ -302,7 +437,7 @@ for (const p of selected) {
                 chosen = answered(
                     await multiselect({
                         message: `${p.label} — which modules should start ON? (everything stays in the code; off = dormant, ready when you need it)`,
-                        options: questions.modules.options.map((m) => ({ value: m, label: m })),
+                        options: questions.modules.options.map((m) => ({ value: m, label: m, hint: questions.modules?.descriptions?.[m] })),
                         initialValues: questions.modules.initial,
                         required: false,
                     }),
@@ -316,6 +451,21 @@ for (const p of selected) {
             setupArgs.push("--modules", chosen.join(","));
         }
 
+        if (questions?.runtime && questions.runtime.options.length > 1) {
+            const rt = answered(
+                await select({
+                    message: `${p.label} — where will you deploy?`,
+                    options: questions.runtime.options.map((o) => ({
+                        value: o,
+                        label: o,
+                        hint: questions.runtime?.descriptions?.[o],
+                    })),
+                    initialValue: questions.runtime.initial,
+                }),
+            );
+            setupArgs.push("--runtime", rt as string);
+        }
+
         const s3 = spinner();
         s3.start(`${p.label} — applying your setup (modules, fresh secrets, git)`);
         const setup = Bun.spawnSync(["bun", ...setupArgs], { cwd: dest, stdout: "pipe", stderr: "pipe" });
@@ -324,7 +474,7 @@ for (const p of selected) {
         } else {
             s3.stop(`${p.label} — setup didn't finish`);
             note(
-                `Everything downloaded fine — just finish it yourself:\n  cd ${appName}/${p.folder} && bun run setup`,
+                `Everything downloaded fine — just finish it yourself:\n  cd ${displayRoot}/${p.folder} && bun run setup`,
                 "Heads up",
             );
         }
@@ -350,16 +500,16 @@ const server = ready.find((p) => p.id === "server");
 const client = ready.find((p) => p.id === "client");
 if (server) {
     steps.push(
-        `Start the backend:\n  cd ${appName}/server\n  docker compose up -d && bun run db:migrate && bun dev`,
+        `Start the backend:\n  cd ${displayRoot}/server\n  docker compose up -d && bun run db:migrate && bun dev`,
     );
 }
 if (client) {
-    steps.push(`Start the web app:\n  cd ${appName}/client\n  bun dev`);
+    steps.push(`Start the web app:\n  cd ${displayRoot}/client\n  bun dev`);
 }
 steps.push(
     `When you're ready to publish (each part is its own repo):\n` +
         ready
-            .map((p) => `  cd ${appName}/${p.folder} && git remote add origin <your-repo> && git push -u origin main`)
+            .map((p) => `  cd ${displayRoot}/${p.folder} && git remote add origin <your-repo> && git push -u origin main`)
             .join("\n"),
 );
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-macostack",
-    "version": "0.2.1",
+    "version": "0.4.0",
     "description": "Private macostack scaffold orchestrator for detached server/client repos.",
     "type": "module",
     "bin": {