create-stardrive 1.1.0 → 1.2.0

package/bin/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import path3 from "node:path";
+import path4 from "node:path";
 
 // src/args.ts
 function parseArgs(argv) {
@@ -84,27 +84,245 @@ var devCommands = {
   bun: "bun run dev"
 };
 
-// src/project-name.ts
+// src/features.ts
 import fs from "node:fs";
 import path from "node:path";
 import readline from "node:readline/promises";
 import { stdin as input, stdout as output2 } from "node:process";
+function removePaths(targetDir2, entries) {
+  for (const entry of entries) {
+    fs.rmSync(path.join(targetDir2, entry), {
+      recursive: true,
+      force: true
+    });
+  }
+}
+function editFile(targetDir2, relativePath, transform) {
+  const filePath = path.join(targetDir2, relativePath);
+  if (!fs.existsSync(filePath)) return;
+  const before = fs.readFileSync(filePath, "utf8");
+  const after = transform(before);
+  if (after !== before) fs.writeFileSync(filePath, after);
+}
+function removeLines(source, pattern) {
+  return source.split("\n").filter((line) => !pattern.test(line)).join("\n");
+}
+function removeBraceBlock(source, startPattern) {
+  const match = startPattern.exec(source);
+  if (!match) return source;
+  const start = match.index;
+  let i = source.indexOf("{", start);
+  if (i === -1) return source;
+  let depth = 0;
+  let end = -1;
+  for (; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end === -1) return source;
+  let after = end + 1;
+  while (after < source.length && /[);,]/.test(source[after])) after++;
+  if (source[after] === "\n") after++;
+  let head = start;
+  while (head > 0 && /[ \t]/.test(source[head - 1])) head--;
+  return source.slice(0, head) + source.slice(after);
+}
+function removeCollectionFromExport(source, name) {
+  return source.replace(
+    /(export const collections\s*=\s*\{)([^}]*)(\};?)/,
+    (_full, open, body, close) => {
+      const items = body.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0 && entry !== name);
+      return `${open} ${items.join(", ")} ${close}`;
+    }
+  );
+}
+function removeBlog(targetDir2) {
+  removePaths(targetDir2, [
+    "src/utils/blog.ts",
+    "src/utils/reading-time.ts",
+    "src/styles/blog.css",
+    "src/pages/rss.xml.js",
+    "src/pages/[lang]/rss.xml.js",
+    "src/pages/blog",
+    "src/pages/[lang]/blog",
+    "src/layouts/article.astro",
+    "src/images/content/articles-fallback.jpg",
+    "src/images/content/articles",
+    "src/content/articles",
+    "src/components/structured/article.astro",
+    "src/components/blog",
+    "scripts/processSocialImages.js",
+    "public/data/articles"
+  ]);
+  editFile(
+    targetDir2,
+    "scripts/postbuild.js",
+    (content) => removeLines(content, /await import\(['"]\.\/processSocialImages\.js['"]\);/)
+  );
+  editFile(targetDir2, "src/content.config.ts", (content) => {
+    const withoutDecl = removeBraceBlock(content, /const articles = defineCollection\(/);
+    return removeCollectionFromExport(withoutDecl, "articles");
+  });
+  editFile(targetDir2, "theme.config.ts", (content) => {
+    const withoutSection = removeBraceBlock(content, /^[ \t]*articles:\s*\{/m);
+    const withoutComment = removeLines(withoutSection, /^\s*\/\/ content\/article settings\s*$/);
+    return removeLines(withoutComment, /^\s*addArticles:/);
+  });
+}
+function removeFaq(targetDir2) {
+  removePaths(targetDir2, [
+    "src/content/faq-answers",
+    "src/pages/faq.astro",
+    "src/pages/[lang]/faq.astro"
+  ]);
+  editFile(targetDir2, "src/content.config.ts", (content) => {
+    const withoutDecl = removeBraceBlock(content, /const faq_answers = defineCollection\(/);
+    return removeCollectionFromExport(withoutDecl, "faq_answers");
+  });
+  editFile(
+    targetDir2,
+    "theme.config.ts",
+    (content) => removeLines(content, /^\s*addFAQ:/)
+  );
+}
+function removeIntegration(targetDir2) {
+  removePaths(targetDir2, [
+    "src/images/content/integration",
+    "src/content/integration-options",
+    "src/pages/integration",
+    "src/pages/[lang]/integration",
+    "src/components/integration-list.astro"
+  ]);
+  editFile(targetDir2, "src/content.config.ts", (content) => {
+    const withoutDecl = removeBraceBlock(
+      content,
+      /const integration_options = defineCollection\(/
+    );
+    return removeCollectionFromExport(withoutDecl, "integration_options");
+  });
+}
+function cleanupNav(targetDir2, removed) {
+  const routes = [
+    removed.blog ? "blog" : null,
+    removed.faq ? "faq" : null,
+    removed.integration ? "integration" : null
+  ].filter((route) => route !== null);
+  if (routes.length === 0) return;
+  const pattern = new RegExp(
+    `getLocaleUrl\\(['"](?:${routes.join("|")})['"]`
+  );
+  editFile(
+    targetDir2,
+    "src/components/layout/nav/footer-nav.astro",
+    (content) => removeLines(content, pattern)
+  );
+}
+function removeCloudflare(targetDir2) {
+  removePaths(targetDir2, [
+    "scripts/purgeCloudflareCache.js",
+    "worker-configuration.d.ts",
+    "wrangler.jsonc",
+    "public/_headers"
+  ]);
+  editFile(targetDir2, "astro.config.ts", (content) => {
+    const withoutImport = removeLines(
+      content,
+      /^import cloudflare from ['"]@astrojs\/cloudflare['"];/
+    );
+    return removeLines(withoutImport, /^\s*adapter: cloudflare\(/);
+  });
+  const packageJsonPath = path.join(targetDir2, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(
+      fs.readFileSync(packageJsonPath, "utf8")
+    );
+    if (pkg.scripts) delete pkg.scripts["purge:cloudflare"];
+    if (pkg.dependencies) {
+      delete pkg.dependencies["@astrojs/cloudflare"];
+      delete pkg.dependencies["wrangler"];
+    }
+    if (pkg.devDependencies) {
+      delete pkg.devDependencies["@astrojs/cloudflare"];
+      delete pkg.devDependencies["wrangler"];
+    }
+    fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
+  }
+}
+async function confirm(rl, question, defaultYes = true) {
+  const hint = defaultYes ? "(Y/n)" : "(y/N)";
+  const answer = (await rl.question(`${c.cyan("?")} ${c.bold(question)} ${c.dim(`${hint} `)}`)).trim().toLowerCase();
+  if (!answer) return defaultYes;
+  return answer === "y" || answer === "yes";
+}
+async function configureFeatures(targetDir2) {
+  step("Configuring optional features");
+  if (!input.isTTY) {
+    info("Non-interactive shell detected; keeping all features.");
+    return;
+  }
+  const rl = readline.createInterface({ input, output: output2 });
+  try {
+    const keepBlog = await confirm(rl, "Keep the blog feature?");
+    if (!keepBlog) {
+      removeBlog(targetDir2);
+      ok("Removed the blog feature");
+    }
+    const keepFaq = await confirm(rl, "Keep the FAQ feature?");
+    if (!keepFaq) {
+      removeFaq(targetDir2);
+      ok("Removed the FAQ feature");
+    }
+    const keepIntegration = await confirm(rl, "Keep the integration catalog?");
+    if (!keepIntegration) {
+      removeIntegration(targetDir2);
+      ok("Removed the integration catalog");
+    }
+    cleanupNav(targetDir2, {
+      blog: !keepBlog,
+      faq: !keepFaq,
+      integration: !keepIntegration
+    });
+    const useCloudflare = await confirm(
+      rl,
+      "Will you host on Cloudflare Workers?"
+    );
+    if (!useCloudflare) {
+      removeCloudflare(targetDir2);
+      ok("Removed Cloudflare-specific setup");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/project-name.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import readline2 from "node:readline/promises";
+import { stdin as input2, stdout as output3 } from "node:process";
 function isValidProjectName(name) {
   return /^[a-z0-9._-]+$/i.test(name) && !/^[._]/.test(name);
 }
 async function askProjectName(initial) {
   if (initial && isValidProjectName(initial)) {
-    const targetDir2 = path.resolve(initial);
-    if (!fs.existsSync(targetDir2)) return initial;
+    const targetDir2 = path2.resolve(initial);
+    if (!fs2.existsSync(targetDir2)) return initial;
     fail(`Directory "${initial}" already exists.`);
   }
-  if (!input.isTTY) {
+  if (!input2.isTTY) {
     fail(
       `Project name "${initial ?? ""}" is missing or invalid and stdin is not interactive.`
     );
     process.exit(1);
   }
-  const rl = readline.createInterface({ input, output: output2 });
+  const rl = readline2.createInterface({ input: input2, output: output3 });
   try {
     while (true) {
       const answer = (await rl.question(
@@ -117,8 +335,8 @@ async function askProjectName(initial) {
         );
         continue;
       }
-      const targetDir2 = path.resolve(name);
-      if (fs.existsSync(targetDir2)) {
+      const targetDir2 = path2.resolve(name);
+      if (fs2.existsSync(targetDir2)) {
         console.log(
           `  ${c.yellow("!")} "${name}" already exists. Try another.`
         );
@@ -147,10 +365,10 @@ function compareSemver(a, b) {
   return 0;
 }
 function resolveTag(requestedVersion2) {
-  const output3 = execSync(`git ls-remote --tags --refs ${STARDRIVE_REPO}`, {
+  const output4 = execSync(`git ls-remote --tags --refs ${STARDRIVE_REPO}`, {
     encoding: "utf8"
   });
-  const tags = output3.split("\n").map((line) => line.split("refs/tags/")[1]).filter((t) => Boolean(t));
+  const tags = output4.split("\n").map((line) => line.split("refs/tags/")[1]).filter((t) => Boolean(t));
   if (requestedVersion2) {
     const wanted = normalizeTag(requestedVersion2);
     if (!tags.includes(wanted)) {
@@ -168,11 +386,11 @@ function resolveTag(requestedVersion2) {
 }
 
 // src/scaffold.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import os from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 import { execSync as execSync2 } from "node:child_process";
-var TRIM_ENTRIES = ["scripts/syncVersion.js", "SECURITY.md", ".github"];
+var TRIM_ENTRIES = ["scripts/syncVersion.js", ".ai/TRIMMING_GUIDE.md", "SECURITY.md", ".github"];
 var STALE_LOCKFILES = [
   "package-lock.json",
   "pnpm-lock.yaml",
@@ -180,7 +398,7 @@ var STALE_LOCKFILES = [
   "bun.lockb"
 ];
 function cloneRepo(tag2, targetDir2, projectName2) {
-  const tempDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "create-app-"));
+  const tempDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "create-app-"));
   step(`Beaming ${c.bold(tag2)} down from orbit`);
   info(STARDRIVE_REPO);
   execSync2(
@@ -189,11 +407,11 @@ function cloneRepo(tag2, targetDir2, projectName2) {
       stdio: ["ignore", "ignore", "inherit"]
     }
   );
-  fs2.rmSync(path2.join(tempDir, ".git"), {
+  fs3.rmSync(path3.join(tempDir, ".git"), {
     recursive: true,
     force: true
   });
-  fs2.cpSync(tempDir, targetDir2, {
+  fs3.cpSync(tempDir, targetDir2, {
     recursive: true
   });
   ok(`Landed in ${c.bold(projectName2)}/`);
@@ -201,13 +419,13 @@ function cloneRepo(tag2, targetDir2, projectName2) {
 function trimProject(targetDir2) {
   step("Trimming unused boosters");
   for (const entry of TRIM_ENTRIES) {
-    fs2.rmSync(path2.join(targetDir2, entry), {
+    fs3.rmSync(path3.join(targetDir2, entry), {
       recursive: true,
       force: true
     });
   }
   for (const file of STALE_LOCKFILES) {
-    fs2.rmSync(path2.join(targetDir2, file), {
+    fs3.rmSync(path3.join(targetDir2, file), {
       force: true
     });
   }
@@ -215,9 +433,9 @@ function trimProject(targetDir2) {
 }
 function calibratePackageJson(targetDir2, projectName2, pm2) {
   step("Calibrating package.json");
-  const packageJsonPath = path2.join(targetDir2, "package.json");
+  const packageJsonPath = path3.join(targetDir2, "package.json");
   const pkg = JSON.parse(
-    fs2.readFileSync(packageJsonPath, "utf8")
+    fs3.readFileSync(packageJsonPath, "utf8")
   );
   pkg.name = projectName2;
   if (pkg.scripts) {
@@ -230,7 +448,7 @@ function calibratePackageJson(targetDir2, projectName2, pm2) {
   if (pm2 === "bun") {
     pkg.packageManager = `bun@${execSync2("bun --version").toString().trim()}`;
   }
-  fs2.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
+  fs3.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2));
   ok(`Named your ship ${c.bold(projectName2)}`);
 }
 function installDependencies(targetDir2, projectName2, pm2, skipInstall2) {
@@ -256,13 +474,14 @@ if (!commandExists(pm)) {
 }
 console.log(banner);
 var projectName = await askProjectName(positional[0]);
-var targetDir = path3.resolve(projectName);
+var targetDir = path4.resolve(projectName);
 step("Locating the latest Stardrive release");
 var tag = resolveTag(requestedVersion);
 ok(`Selected ${c.bold(tag)}`);
 cloneRepo(tag, targetDir, projectName);
 trimProject(targetDir);
 calibratePackageJson(targetDir, projectName, pm);
+await configureFeatures(targetDir);
 installDependencies(targetDir, projectName, pm, skipInstall);
 console.log(`
 ${c.green("All systems go.")} ${c.dim("Pre-flight checklist complete.")}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-stardrive",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "This is the launchpad application to create the Astro Stardrive boilerplate.",
   "bin": {
     "create-stardrive": "bin/index.js"
@@ -51,8 +51,8 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@types/node": "^22.10.2",
-    "esbuild": "^0.24.2",
-    "typescript": "^5.7.2"
+    "@types/node": "^26.0.0",
+    "esbuild": "^0.28.1",
+    "typescript": "^6.0.3"
   }
 }