create-macostack 0.2.0 → 0.3.0

package/bin/create-macostack.ts

@@ -1,27 +1,24 @@
 #!/usr/bin/env bun
 import {
     cancel,
-    confirm,
     intro,
     isCancel,
-    log,
     multiselect,
     note,
     outro,
+    select,
     spinner,
     text,
 } from "@clack/prompts";
 import {
-    closeSync,
     existsSync,
     mkdirSync,
     mkdtempSync,
-    openSync,
     readdirSync,
     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.
@@ -92,6 +89,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)
@@ -127,29 +125,6 @@ const answered = <T>(value: T | symbol): T => {
     return value as T;
 };
 
-// The setup wizards downstream are interactive. Under `bun create` / `bunx`,
-// stdin often arrives as a pipe (not a TTY) even though a human is right
-// there — so we hand children the real terminal via /dev/tty.
-const openTty = (): number | null => {
-    try {
-        return openSync("/dev/tty", "r");
-    } catch {
-        return null;
-    }
-};
-
-const run = (command: string[], cwd: string) => {
-    const ttyFd = openTty();
-    const result = Bun.spawnSync(command, {
-        cwd,
-        stdin: ttyFd ?? "inherit",
-        stdout: "inherit",
-        stderr: "inherit",
-    });
-    if (ttyFd !== null) closeSync(ttyFd);
-    return result.exitCode;
-};
-
 const githubToken = (): string | null => {
     const fromEnv = Bun.env.GITHUB_TOKEN ?? Bun.env.GH_TOKEN;
     if (fromEnv) return fromEnv;
@@ -166,13 +141,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");
     }
@@ -191,27 +186,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?: { options: string[]; initial: string[]; exclusive?: string[][] } } | 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 })),
+                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.
@@ -286,7 +376,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();
@@ -295,23 +385,63 @@ 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})`,
         );
     }
 
-    // Hand over to the template's own wizard — it knows its modules, we don't.
+    // Configure the template. It OWNS its questions — we fetch them as data
+    // (`setup --questions`), ask them in THIS wizard (nested interactive
+    // prompts don't get keyboard control under `bun create`), and apply the
+    // answers non-interactively (`setup --yes`).
     const pkg = existsSync(resolve(dest, "package.json"))
         ? await Bun.file(resolve(dest, "package.json")).json()
         : null;
     if (!flags["skip-setup"] && pkg?.scripts?.setup) {
-        log.step(`Now shaping the ${p.label.toLowerCase()} — its own wizard takes it from here:`);
-        const args = flags.yes
-            ? ["run", "setup", "--yes", "--name", appName]
-            : ["run", "setup", "--name", appName];
-        const code = run(["bun", ...args], dest);
-        if (code !== 0) {
+        let questions: { modules?: { options: string[]; initial: string[]; exclusive?: string[][] } } | null = null;
+        if (!flags.yes) {
+            const q = Bun.spawnSync(["bun", "run", "setup", "--questions"], {
+                cwd: dest,
+                stdout: "pipe",
+                stderr: "pipe",
+            });
+            if (q.exitCode === 0) {
+                try {
+                    questions = JSON.parse(q.stdout.toString().trim().split("\n").at(-1) ?? "");
+                } catch {}
+            }
+        }
+
+        const setupArgs = ["run", "setup", "--yes", "--name", appName];
+
+        if (questions?.modules) {
+            let chosen: string[];
+            for (;;) {
+                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 })),
+                        initialValues: questions.modules.initial,
+                        required: false,
+                    }),
+                );
+                const clash = (questions.modules.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");
+            }
+            setupArgs.push("--modules", chosen.join(","));
+        }
+
+        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" });
+        if (setup.exitCode === 0) {
+            s3.stop(`${p.label} — configured`);
+        } else {
+            s3.stop(`${p.label} — setup didn't finish`);
             note(
-                `The ${p.folder} wizard didn't finish. Everything downloaded fine — resume with:\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",
             );
         }
@@ -337,16 +467,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.0",
+    "version": "0.3.0",
     "description": "Private macostack scaffold orchestrator for detached server/client repos.",
     "type": "module",
     "bin": {