create-shibumi 0.2.9 → 0.3.0

package/README.md

@@ -8,27 +8,40 @@ cd my-app
 bun dev
 ```
 
+Already have a project? Run it inside that project instead, and it gets deploy tooling rather than a scaffold:
+
+```sh
+bun create shibumi@latest .
+```
+
 ## Three starting points
 
-1. **Static site**: publish a verified build directory such as `./dist`, `public`, `build`, or `out` from any framework.
-2. **Bun web**: Hono, HTML, CSS, Alpine, Zod, tests, and a health endpoint.
-3. **SQLite full stack**: the Bun web project plus Drizzle, migrations, persistent data, backup, and restore.
+1. **Bun full-stack app**: Hono, HTML, CSS, Alpine, Zod, tests, a health endpoint, and SQLite through Drizzle with migrations, persistent data, backup, and restore.
+2. **Blog**: Astro with posts, RSS, sitemap, SEO meta, and llms.txt.
+3. **Static site**: publish a verified build directory such as `./dist`, `public`, `build`, or `out` from any framework.
 
 All three deploy to a Linux VPS or homelab through [shibumi-server](https://server.shibumistack.dev). Other providers can wait until their generated projects pass the same artifact and deployment tests.
 
 ## Flags
 
 ```text
---template <id>       static, web, or full-stack
+--template <id>       full-stack, blog, or static
 --yes, -y             non-interactive; requires name and --template
 --no-git              skip git init
 --no-install          skip dependency install
+--spa                 adopting only: unknown paths serve index.html
 --help, -h            show help
 --version             show version
 ```
 
 Creation is atomic: the project is built in a temporary sibling directory and renamed into place. Failure or cancellation leaves nothing behind, and an existing destination is never touched. Git init stages and commits nothing; the first commit belongs to you.
 
+## Adopting an existing project
+
+`bun create shibumi .` detects where your build lands (Astro and Vite write `dist/`, Eleventy `_site/`, an exported Next.js `out/`, plain files `public/`), vendors `scripts/ship.ts`, adds the `ship` scripts, installs the one dependency that client needs, and generates a `Dockerfile`, `compose.yaml`, and `.dockerignore` for the static image. Git is never touched, and `--no-install` skips the install.
+
+Two cases stop the run instead of guessing. Deployment files that already exist are never reinterpreted: a `compose.yaml` carrying Shibumi's static labels beside somebody else's `Dockerfile` would deploy the wrong artifact. A `package.json` with a `start` script belongs to `bun ship:setup`, which generates server deployment files. Finish with `bun ship:setup`.
+
 ## Guidance for coding agents
 
 Generated projects include a root `agents.md`. It records route locations, data rules, available checks, and files that need extra care.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-shibumi",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "Scaffold a Shibumi Stack project: Bun, Hono, Zod, Drizzle, SQLite, Alpine",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "src/cli.ts",
     "src/args.ts",
+    "src/adopt.ts",
     "src/create.ts",
     "src/templates/ship.ts",
     "src/templates/shibumi.ts",
@@ -17,7 +18,6 @@
     "src/templates/static/",
     "src/templates/blog/",
     "src/templates/full-stack/",
-    "src/templates/web/",
     "README.md",
     "LICENSE"
   ],

package/scripts/ship.lock.json

@@ -1,4 +1,4 @@
 {
-  "url": "https://shibumistack.dev/ship/v47.ts",
-  "sha256": "7c4bee760498bea9f857934088e9fc1e3c1b835dfd49deb382d103248adedc63"
+  "url": "https://shibumistack.dev/ship/v48.ts",
+  "sha256": "425a8ca3d0b9b8b27660906ea38ec9acb3441a0e0fcf0bd3be191a8e3bd5bea6"
 }

package/src/adopt.ts

@@ -0,0 +1,250 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+const DEFAULT_TEMPLATES_DIR = join(import.meta.dir, "templates");
+export const CLACK_VERSION = (
+  JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf8")) as {
+    dependencies: Record<string, string>;
+  }
+).dependencies["@clack/prompts"]!;
+
+/**
+ * How to install the client's one dependency here. A project with an npm or
+ * pnpm lockfile must not get a bun.lock dropped beside it, so those get the
+ * matching command to run instead of a silent second lockfile.
+ */
+export function dependencyInstall(lockfiles: string[]): { command: string[]; manual?: string } {
+  const pinned = `@clack/prompts@${CLACK_VERSION}`;
+  if (lockfiles.includes("package-lock.json")) return { command: [], manual: `npm install --save-dev ${pinned}` };
+  if (lockfiles.includes("pnpm-lock.yaml")) return { command: [], manual: `pnpm add -D ${pinned}` };
+  if (lockfiles.includes("yarn.lock")) return { command: [], manual: `yarn add --dev --exact ${pinned}` };
+  // --exact keeps the version this package pins, instead of widening it to ^.
+  return { command: ["bun", "add", "--dev", "--exact", pinned] };
+}
+
+export interface DetectedOutput {
+  framework: string;
+  outputDir: string;
+  // "framework" means a build tool named the directory; "directory" means the
+  // directory was simply there, which a Bun server app's dist/ also satisfies.
+  source: "framework" | "directory";
+}
+
+/**
+ * Where this project's build lands. Framework signals come first (Astro and
+ * Eleventy both pull Vite in, so a bare Vite match must lose), then a build
+ * directory that is already on disk, then plain files under public/.
+ */
+export function detectBuildOutput(input: {
+  dependencies?: Record<string, unknown>;
+  files: string[];
+  directories?: string[];
+}): DetectedOutput | undefined {
+  const dependencies = input.dependencies ?? {};
+  const dep = (name: string) => name in dependencies;
+  const file = (name: string) => input.files.includes(name);
+  // A plain file named dist must never satisfy a directory fallback.
+  const directory = (name: string) => (input.directories ?? []).includes(name);
+  const config = (base: string) =>
+    ["js", "mjs", "cjs", "ts"].some((extension) => file(`${base}.${extension}`));
+
+  const framework = (name: string, outputDir: string): DetectedOutput => ({ framework: name, outputDir, source: "framework" });
+  if (dep("astro") || config("astro.config")) return framework("Astro", "dist");
+  if (dep("@11ty/eleventy") || config(".eleventy") || config("eleventy.config")) {
+    return framework("Eleventy", "_site");
+  }
+  if (dep("next") || config("next.config")) return framework("Next.js", "out");
+  if (dep("vite") || config("vite.config")) return framework("Vite", "dist");
+  for (const candidate of ["dist", "_site", "out", "build"]) {
+    if (directory(candidate)) return { framework: "existing build output", outputDir: candidate, source: "directory" };
+  }
+  if (directory("public")) return { framework: "plain files", outputDir: "public", source: "directory" };
+  return undefined;
+}
+
+export function shipScripts(config: {
+  outputDir: string;
+  buildScript?: string;
+  spa: boolean;
+}): Record<string, string> {
+  const setup = [
+    "bun scripts/ship.ts --setup --static",
+    `--output-dir ${config.outputDir}`,
+    ...(config.buildScript ? [`--build-script ${config.buildScript}`] : []),
+    config.spa ? "--spa" : "--no-spa",
+  ].join(" ");
+  return {
+    ship: "bun scripts/ship.ts",
+    "ship:setup": setup,
+    "ship:update": "bun scripts/ship.ts --update",
+    "ship:status": "bun scripts/ship.ts --status",
+    "ship:logs": "bun scripts/ship.ts --logs",
+    "ship:webhook": "bun scripts/ship.ts --webhook",
+  };
+}
+
+// The generators for the static image live in the Ship client, so adopted
+// projects get byte-identical deployment files to the ones ship:setup writes.
+// The specifier stays computed on purpose: the client is a vendored artifact
+// with its own compiler settings and must not join this package's tsc program.
+export interface ShipStatic {
+  staticDeploymentFileTemplates(config: {
+    outputDir: string;
+    buildScript?: string;
+    spa: boolean;
+  }): Record<string, string>;
+  staticServerSource(outputDir: string): string;
+  staticOutputDirProblem(value: string): string | undefined;
+}
+
+export class AdoptError extends Error {
+  exitCode: number;
+  constructor(message: string, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+}
+
+function verifiedShipPath(templatesDir: string): string {
+  const shipPath = join(templatesDir, "ship.ts");
+  if (!existsSync(shipPath)) {
+    throw new AdoptError(`Vendored Ship client missing at ${shipPath}; aborting.`);
+  }
+  if (templatesDir === DEFAULT_TEMPLATES_DIR) {
+    const lock = JSON.parse(
+      readFileSync(join(import.meta.dir, "..", "scripts", "ship.lock.json"), "utf8")
+    ) as { sha256: string };
+    const digest = new Bun.CryptoHasher("sha256").update(readFileSync(shipPath)).digest("hex");
+    if (digest !== lock.sha256) {
+      throw new AdoptError(
+        `Vendored Ship client does not match its checksum lock; the package may be corrupt. Reinstall create-shibumi.`
+      );
+    }
+  }
+  return shipPath;
+}
+
+export async function loadShipStatic(templatesDir = DEFAULT_TEMPLATES_DIR): Promise<ShipStatic> {
+  return (await import(verifiedShipPath(templatesDir))) as ShipStatic;
+}
+
+export interface AdoptOptions {
+  root: string;
+  outputDir: string;
+  buildScript?: string;
+  spa: boolean;
+  ship: ShipStatic;
+  templatesDir?: string;
+}
+
+export interface AdoptResult {
+  written: string[];
+  kept: string[];
+  scripts: string[];
+  dependency: boolean;
+}
+
+function trackedState(root: string, path: string): "tracked" | "untracked" | "no-repository" {
+  const listed = Bun.spawnSync(["git", "ls-files", "--", path], { cwd: root, stdout: "pipe", stderr: "pipe" });
+  if (listed.exitCode !== 0) return "no-repository";
+  return listed.stdout.toString().trim() ? "tracked" : "untracked";
+}
+
+/**
+ * Vendor the Ship client into an existing project instead of scaffolding a new
+ * one. Refuses rather than reinterpreting a project's own packaging: deployment
+ * files that already exist may build or run something else entirely.
+ */
+export async function adoptProject(opts: AdoptOptions): Promise<AdoptResult> {
+  const problem = opts.ship.staticOutputDirProblem(opts.outputDir);
+  if (problem) throw new AdoptError(problem, 2);
+
+  const templates = opts.ship.staticDeploymentFileTemplates({
+    outputDir: opts.outputDir,
+    buildScript: opts.buildScript,
+    spa: opts.spa,
+  });
+  // Same refusal ship:setup makes: a compose file carrying shibumi static
+  // labels next to somebody else's Dockerfile deploys the wrong artifact.
+  const targets = [...Object.keys(templates), ...(opts.spa ? ["scripts/static-server.ts"] : [])];
+  const conflicts = targets.filter((name) => existsSync(join(opts.root, name)));
+  if (conflicts.length > 0) {
+    throw new AdoptError(
+      `Adopting would generate ${conflicts.join(", ")}, which already exist and may package or run something else.\n\nNext: remove or rename them, then run bun create shibumi . again.`
+    );
+  }
+  // Without a build script the image can only contain what the commit
+  // contains, so the output has to be in git already.
+  const state = opts.buildScript ? "tracked" : trackedState(opts.root, opts.outputDir);
+  if (state !== "tracked") {
+    const next = state === "no-repository"
+      ? `git init && git add ${opts.outputDir} && git commit -m "Add site"`
+      : `commit ${opts.outputDir}/`;
+    throw new AdoptError(
+      `Without a build script, ${opts.outputDir}/ must be committed so shipped images match the exact commit.\n\nNext: ${next}, or add a build script to package.json, then run bun create shibumi . again.`
+    );
+  }
+
+  const templatesDir = opts.templatesDir ?? DEFAULT_TEMPLATES_DIR;
+  const written: string[] = [];
+  const kept: string[] = [];
+
+  if (existsSync(join(opts.root, "scripts", "ship.ts"))) {
+    kept.push("scripts/ship.ts");
+  } else {
+    mkdirSync(join(opts.root, "scripts"), { recursive: true });
+    copyFileSync(verifiedShipPath(templatesDir), join(opts.root, "scripts", "ship.ts"));
+    written.push("scripts/ship.ts");
+  }
+
+  // Script-less generators (Jekyll) have no package.json; the ship commands
+  // and the client's own dependency need one.
+  const packagePath = join(opts.root, "package.json");
+  const before = existsSync(packagePath) ? readFileSync(packagePath, "utf8") : undefined;
+  const pkg = (before === undefined
+    ? {
+        name: opts.root.split("/").pop()?.toLowerCase().replace(/[^a-z0-9._-]+/g, "-") || "app",
+        private: true,
+        type: "module",
+      }
+    : JSON.parse(before)) as {
+    scripts?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    dependencies?: Record<string, string>;
+  };
+
+  const scripts = pkg.scripts ?? {};
+  const added: string[] = [];
+  for (const [name, command] of Object.entries(
+    shipScripts({ outputDir: opts.outputDir, buildScript: opts.buildScript, spa: opts.spa })
+  )) {
+    if (scripts[name]) continue;
+    scripts[name] = command;
+    added.push(name);
+  }
+  pkg.scripts = scripts;
+  // The vendored client imports @clack/prompts; an adopted project with an
+  // existing node_modules gets no auto-install, so the dependency is declared
+  // and installed.
+  const dependency = !pkg.dependencies?.["@clack/prompts"] && !pkg.devDependencies?.["@clack/prompts"];
+  if (dependency) pkg.devDependencies = { ...pkg.devDependencies, "@clack/prompts": CLACK_VERSION };
+  const after = `${JSON.stringify(pkg, null, 2)}\n`;
+  if (after !== before) {
+    writeFileSync(packagePath, after, { mode: 0o644 });
+    written.push("package.json");
+  } else {
+    kept.push("package.json");
+  }
+
+  for (const [name, contents] of Object.entries(templates)) {
+    writeFileSync(join(opts.root, name), contents, { mode: 0o644 });
+    written.push(name);
+  }
+  if (opts.spa) {
+    mkdirSync(join(opts.root, "scripts"), { recursive: true });
+    writeFileSync(join(opts.root, "scripts", "static-server.ts"), opts.ship.staticServerSource(opts.outputDir), { mode: 0o644 });
+    written.push("scripts/static-server.ts");
+  }
+
+  return { written, kept, scripts: added, dependency };
+}

package/src/args.ts

@@ -1,4 +1,4 @@
-export const TEMPLATES = ["static", "web", "full-stack", "blog"] as const;
+export const TEMPLATES = ["static", "full-stack", "blog"] as const;
 export type TemplateId = (typeof TEMPLATES)[number];
 
 export interface ParsedArgs {
@@ -7,6 +7,9 @@ export interface ParsedArgs {
   yes: boolean;
   git: boolean;
   install: boolean;
+  // `bun create shibumi .` adopts the current project instead of scaffolding.
+  adopt: boolean;
+  spa: boolean;
   name?: string;
   template?: TemplateId;
 }
@@ -41,6 +44,7 @@ const BOOLEAN_FLAGS = new Set([
   "-y",
   "--no-git",
   "--no-install",
+  "--spa",
 ]);
 
 export function validateName(name: string): string | null {
@@ -60,6 +64,8 @@ export function parseArgs(argv: string[]): ParseResult {
     yes: false,
     git: true,
     install: true,
+    adopt: false,
+    spa: false,
   };
   const positionals: string[] = [];
 
@@ -110,6 +116,7 @@ export function parseArgs(argv: string[]): ParseResult {
       else if (flag === "--yes" || flag === "-y") args.yes = true;
       else if (flag === "--no-git") args.git = false;
       else if (flag === "--no-install") args.install = false;
+      else if (flag === "--spa") args.spa = true;
       continue;
     }
 
@@ -127,12 +134,29 @@ export function parseArgs(argv: string[]): ParseResult {
     };
   }
   if (positionals.length === 1) {
-    const err = validateName(positionals[0]!);
-    if (err) return { ok: false, error: err };
-    args.name = positionals[0]!;
+    if (positionals[0] === ".") {
+      args.adopt = true;
+    } else {
+      const err = validateName(positionals[0]!);
+      if (err) return { ok: false, error: err };
+      args.name = positionals[0]!;
+    }
+  }
+
+  if (args.spa && !args.adopt) {
+    return {
+      ok: false,
+      error: `--spa applies to adopting an existing project: bun create shibumi .`,
+    };
+  }
+  if (args.adopt && args.template) {
+    return {
+      ok: false,
+      error: `--template does not apply to an existing project; bun create shibumi . adds deploy tooling to what is already here.`,
+    };
   }
 
-  if (args.yes) {
+  if (args.yes && !args.adopt) {
     if (!args.name) {
       return { ok: false, error: `--yes requires a project name.` };
     }
@@ -148,13 +172,15 @@ export const HELP_TEXT = `create-shibumi: scaffold a Shibumi Stack project
 
 Usage
   bun create shibumi@latest [name] [flags]
+  bun create shibumi@latest .           add deploy tooling to this project
   bunx create-shibumi [name] [flags]
 
 Flags
-  --template <id>       static, web, full-stack, or blog
+  --template <id>       full-stack, blog, or static
   --yes, -y             non-interactive; requires name and --template
   --no-git              skip git init
   --no-install          skip dependency install
+  --spa                 adopting only: unknown paths serve index.html
   --help, -h            show this help
   --version             show version