astro-config-cli 1.0.0

package/README.md

@@ -0,0 +1,73 @@
+# astro-config-cli
+
+CLI tool for generating and managing Astro framework configuration files
+
+## Installation
+
+```bash
+npm install -g astro-config-cli
+```
+
+## Usage
+
+### Initialize configuration
+
+```bash
+astro-config init
+astro-config init --template advanced
+astro-config init --output custom-config.json
+```
+
+### Validate configuration
+
+```bash
+astro-config validate
+astro-config validate path/to/config.json
+```
+
+### View configuration
+
+```bash
+astro-config show
+astro-config show --env production
+astro-config show --json
+```
+
+### Modify configuration
+
+```bash
+astro-config set settings.debug true
+astro-config set settings.logLevel \"warn\"
+```
+
+### Compare configurations
+
+```bash
+astro-config diff config-dev.json config-prod.json
+```
+
+### List templates
+
+```bash
+astro-config templates
+```
+
+## Templates
+
+| Template | Description |
+|----------|-------------|
+| `minimal` | Bare minimum configuration |
+| `standard` | Recommended defaults for most projects |
+| `advanced` | Full-featured with security, caching, and multi-environment support |
+
+## Why astro-config-cli?
+
+- **Zero dependencies at runtime** — just `commander` and `chalk`
+- **Template-based** — start with minimal, standard, or advanced presets
+- **Validation built-in** — catch config errors before deployment
+- **Environment-aware** — manage dev/staging/production configs in one file
+- **Diff support** — compare configs across environments
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import fs from "fs";
+var CONFIG_FILE = "astro-cli.json";
+function loadConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    } catch {
+      console.error(chalk.red("Error: Could not parse " + CONFIG_FILE));
+      process.exit(1);
+    }
+  }
+  return {};
+}
+function saveConfig(cfg) {
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+  console.log(chalk.green("\u2714") + "  Config saved to " + chalk.cyan(CONFIG_FILE));
+}
+function integrationImport(name) {
+  const map = {
+    react: "import react from '@astrojs/react';",
+    vue: "import vue from '@astrojs/vue';",
+    svelte: "import svelte from '@astrojs/svelte';",
+    tailwind: "import tailwind from '@astrojs/tailwind';",
+    mdx: "import mdx from '@astrojs/mdx';",
+    sitemap: "import sitemap from '@astrojs/sitemap';",
+    partytown: "import partytown from '@astrojs/partytown';"
+  };
+  return map[name];
+}
+function integrationCall(name) {
+  const map = {
+    react: "react()",
+    vue: "vue()",
+    svelte: "svelte()",
+    tailwind: "tailwind()",
+    mdx: "mdx()",
+    sitemap: "sitemap()",
+    partytown: 'partytown({ config: { forward: ["dataLayer.push"] } })'
+  };
+  return map[name];
+}
+function adapterImport(name) {
+  const map = {
+    node: "import node from '@astrojs/node';",
+    vercel: "import vercel from '@astrojs/vercel/serverless';",
+    netlify: "import netlify from '@astrojs/netlify';",
+    cloudflare: "import cloudflare from '@astrojs/cloudflare';",
+    deno: "import deno from '@astrojs/deno';"
+  };
+  return map[name];
+}
+function adapterCall(name, opts) {
+  if (Object.keys(opts).length === 0) return `${name}()`;
+  const args = JSON.stringify(opts, null, 2).replace(/^{/, "").replace(/}$/, "").trim();
+  return `${name}({ ${args.replace(/\n/g, " ")} })`;
+}
+function generateAstroConfig(cfg) {
+  const imports = ["import { defineConfig } from 'astro/config';"];
+  const parts = [];
+  if (cfg.output && cfg.output !== "static") {
+    parts.push(`  output: '${cfg.output}',`);
+  }
+  if (cfg.site) parts.push(`  site: '${cfg.site}',`);
+  if (cfg.base) parts.push(`  base: '${cfg.base}',`);
+  if (cfg.srcDir) parts.push(`  srcDir: '${cfg.srcDir}',`);
+  if (cfg.outDir) parts.push(`  outDir: '${cfg.outDir}',`);
+  if (cfg.publicDir) parts.push(`  publicDir: '${cfg.publicDir}',`);
+  if (cfg.adapter) {
+    imports.push(adapterImport(cfg.adapter));
+    parts.push(`  adapter: ${adapterCall(cfg.adapter, cfg.adapterOptions ?? {})},`);
+  }
+  const integrations = cfg.integrations ?? [];
+  if (integrations.length > 0) {
+    integrations.forEach((i) => imports.push(integrationImport(i)));
+    const calls = integrations.map((i) => "    " + integrationCall(i)).join(",\n");
+    parts.push(`  integrations: [
+${calls},
+  ],`);
+  }
+  if (cfg.image && Object.keys(cfg.image).length > 0) {
+    const img = cfg.image;
+    const imgLines = [];
+    if (img.service) {
+      imgLines.push(`    service: { entrypoint: 'astro/assets/services/${img.service}' },`);
+    }
+    if (img.domains?.length) {
+      imgLines.push(`    domains: ${JSON.stringify(img.domains)},`);
+    }
+    if (img.remotePatterns?.length) {
+      const pats = img.remotePatterns.map((p) => `      { hostname: '${p}' }`).join(",\n");
+      imgLines.push(`    remotePatterns: [
+${pats},
+    ],`);
+    }
+    if (img.format) imgLines.push(`    format: '${img.format}',`);
+    if (img.quality !== void 0) imgLines.push(`    quality: ${img.quality},`);
+    parts.push(`  image: {
+${imgLines.join("\n")}
+  },`);
+  }
+  if (cfg.i18n) {
+    const i = cfg.i18n;
+    const i18n = [
+      `    defaultLocale: '${i.defaultLocale}',`,
+      `    locales: ${JSON.stringify(i.locales)},`
+    ];
+    if (i.routing) {
+      i18n.push(`    routing: { prefixDefaultLocale: ${i.routing === "prefix-always"} },`);
+    }
+    if (i.fallback && Object.keys(i.fallback).length) {
+      i18n.push(`    fallback: ${JSON.stringify(i.fallback)},`);
+    }
+    parts.push(`  i18n: {
+${i18n.join("\n")}
+  },`);
+  }
+  if (cfg.markdown && Object.keys(cfg.markdown).length > 0) {
+    const m = cfg.markdown;
+    const md = [];
+    if (m.syntaxHighlight !== void 0) {
+      md.push(`    syntaxHighlight: ${m.syntaxHighlight === false ? "false" : `'${m.syntaxHighlight}'`},`);
+    }
+    if (m.shikiConfig) md.push(`    shikiConfig: ${JSON.stringify(m.shikiConfig)},`);
+    if (m.gfm !== void 0) md.push(`    gfm: ${m.gfm},`);
+    if (m.smartypants !== void 0) md.push(`    smartypants: ${m.smartypants},`);
+    if (m.remarkPlugins?.length) md.push(`    remarkPlugins: ${JSON.stringify(m.remarkPlugins)},`);
+    if (m.rehypePlugins?.length) md.push(`    rehypePlugins: ${JSON.stringify(m.rehypePlugins)},`);
+    parts.push(`  markdown: {
+${md.join("\n")}
+  },`);
+  }
+  if (cfg.prefetch !== void 0) {
+    if (typeof cfg.prefetch === "boolean") {
+      parts.push(`  prefetch: ${cfg.prefetch},`);
+    } else {
+      const pf = [];
+      if (cfg.prefetch.prefetchAll !== void 0) pf.push(`    prefetchAll: ${cfg.prefetch.prefetchAll},`);
+      if (cfg.prefetch.defaultStrategy) pf.push(`    defaultStrategy: '${cfg.prefetch.defaultStrategy}',`);
+      parts.push(`  prefetch: {
+${pf.join("\n")}
+  },`);
+    }
+  }
+  if (cfg.devToolbar) {
+    parts.push(`  devToolbar: { enabled: ${cfg.devToolbar.enabled ?? true} },`);
+  }
+  if (cfg.vitePlugins?.length) {
+    cfg.vitePlugins.forEach((p) => imports.push(`import ${p.name} from '${p.package}';`));
+    const pluginCalls = cfg.vitePlugins.map((p) => {
+      const opts = p.options && Object.keys(p.options).length ? JSON.stringify(p.options) : "";
+      return `      ${p.name}(${opts})`;
+    }).join(",\n");
+    parts.push(`  vite: {
+    plugins: [
+${pluginCalls},
+    ],
+  },`);
+  }
+  if (cfg.server) {
+    const srv = [];
+    if (cfg.server.port) srv.push(`    port: ${cfg.server.port},`);
+    if (cfg.server.host) srv.push(`    host: '${cfg.server.host}',`);
+    if (srv.length) parts.push(`  server: {
+${srv.join("\n")}
+  },`);
+  }
+  const body = parts.length > 0 ? "\n" + parts.join("\n") + "\n" : "";
+  return `${imports.join("\n")}
+
+export default defineConfig({${body}});
+`;
+}
+function validateConfig(cfg) {
+  const errors = [];
+  if ((cfg.output === "server" || cfg.output === "hybrid") && !cfg.adapter) {
+    errors.push(`output: "${cfg.output}" requires an adapter \u2014 run: astro-config set-adapter <name>`);
+  }
+  if (cfg.i18n) {
+    if (!cfg.i18n.defaultLocale) errors.push("i18n.defaultLocale is required");
+    if (!cfg.i18n.locales?.length) errors.push("i18n.locales must have at least one entry");
+    if (cfg.i18n.locales && cfg.i18n.defaultLocale && !cfg.i18n.locales.includes(cfg.i18n.defaultLocale)) {
+      errors.push("i18n.defaultLocale must appear in i18n.locales");
+    }
+  }
+  if (cfg.image?.quality !== void 0 && (cfg.image.quality < 1 || cfg.image.quality > 100)) {
+    errors.push("image.quality must be between 1 and 100");
+  }
+  return errors;
+}
+var program = new Command();
+program.name("astro-config").description(chalk.cyan("Astro Config CLI") + " \u2014 Generate and manage astro.config.mjs").version("1.0.0");
+program.command("init").description("Initialize a new Astro config (creates astro-cli.json)").option("--output <mode>", "Output mode: static | server | hybrid", "static").option("--site <url>", "Canonical site URL, e.g. https://example.com").option("--base <path>", "Base path, e.g. /app").option("--src <dir>", "Source directory", "./src").option("--out <dir>", "Build output directory", "./dist").option("--port <port>", "Dev server port", "4321").option("--host <host>", "Dev server host (true = expose to LAN)").action((opts) => {
+  const cfg = {
+    output: opts.output,
+    srcDir: opts.src,
+    outDir: opts.out,
+    server: { port: parseInt(opts.port, 10) }
+  };
+  if (opts.host) cfg.server.host = opts.host;
+  if (opts.site) cfg.site = opts.site;
+  if (opts.base) cfg.base = opts.base;
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  Initialized \u2014 output mode: " + chalk.yellow(opts.output));
+  console.log(chalk.dim("  Run `astro-config export` to generate astro.config.mjs"));
+});
+program.command("set-output <mode>").description("Set output mode: static | server | hybrid").action((mode) => {
+  const valid = ["static", "server", "hybrid"];
+  if (!valid.includes(mode)) {
+    console.error(chalk.red("Error: mode must be one of: " + valid.join(", ")));
+    process.exit(1);
+  }
+  const cfg = loadConfig();
+  cfg.output = mode;
+  if (mode !== "static" && !cfg.adapter) {
+    console.log(chalk.yellow("\u26A0") + '  output="' + mode + '" needs an adapter \u2014 run: astro-config set-adapter <name>');
+  }
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  Output set to: " + chalk.yellow(mode));
+});
+var validIntegrations = ["react", "vue", "svelte", "tailwind", "mdx", "sitemap", "partytown"];
+program.command("add-integration <name>").description("Add an integration: " + validIntegrations.join(" | ")).action((name) => {
+  if (!validIntegrations.includes(name)) {
+    console.error(chalk.red('Error: unknown integration "' + name + '"'));
+    console.log("  Available: " + validIntegrations.join(", "));
+    process.exit(1);
+  }
+  const cfg = loadConfig();
+  cfg.integrations = cfg.integrations ?? [];
+  if (cfg.integrations.includes(name)) {
+    console.log(chalk.yellow("\u26A0") + "  " + name + " is already in integrations");
+    return;
+  }
+  cfg.integrations.push(name);
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  Added: " + chalk.cyan(name));
+  console.log(chalk.dim("  npm install @astrojs/" + name));
+});
+var validAdapters = ["node", "vercel", "netlify", "cloudflare", "deno"];
+program.command("set-adapter <name>").description("Set SSR adapter: " + validAdapters.join(" | ")).option("--mode <mode>", "node adapter mode: standalone | middleware", "standalone").option("--region <region>", "Deploy region (vercel / netlify / cloudflare)").option("--runtime <runtime>", "Cloudflare runtime: advanced | directory").action((name, opts) => {
+  if (!validAdapters.includes(name)) {
+    console.error(chalk.red('Error: unknown adapter "' + name + '"'));
+    console.log("  Available: " + validAdapters.join(", "));
+    process.exit(1);
+  }
+  const cfg = loadConfig();
+  cfg.adapter = name;
+  cfg.adapterOptions = {};
+  if (name === "node") cfg.adapterOptions["mode"] = opts.mode;
+  if (name === "cloudflare" && opts.runtime) cfg.adapterOptions["runtime"] = opts.runtime;
+  if ((name === "vercel" || name === "netlify") && opts.region) {
+    cfg.adapterOptions["region"] = opts.region;
+  }
+  if (!cfg.output || cfg.output === "static") {
+    cfg.output = "server";
+    console.log(chalk.yellow("\u26A0") + '  Auto-set output \u2192 "server"');
+  }
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  Adapter: " + chalk.cyan(name));
+  console.log(chalk.dim("  npm install @astrojs/" + name));
+});
+program.command("set-image").description("Configure image optimization").option("--service <svc>", "sharp | squoosh | noop", "sharp").option("--domains <list>", "Comma-separated allowed remote domains").option("--patterns <list>", "Comma-separated remote hostname patterns").option("--format <fmt>", "Default output format: webp | avif | png | jpg").option("--quality <n>", "Default quality 1\u2013100", "80").action((opts) => {
+  const cfg = loadConfig();
+  cfg.image = {
+    service: opts.service,
+    quality: parseInt(opts.quality, 10)
+  };
+  if (opts.domains) cfg.image.domains = opts.domains.split(",").map((d) => d.trim());
+  if (opts.patterns) cfg.image.remotePatterns = opts.patterns.split(",").map((p) => p.trim());
+  if (opts.format) cfg.image.format = opts.format;
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  Image: service=" + chalk.cyan(opts.service) + ", quality=" + opts.quality);
+});
+program.command("set-i18n").description("Configure internationalization routing").requiredOption("--default <locale>", "Default locale, e.g. en").requiredOption("--locales <list>", "Comma-separated locales, e.g. en,fr,de").option("--routing <mode>", "prefix-always | prefix-other-locales", "prefix-other-locales").option("--fallback <json>", `Fallback map JSON, e.g. '{"fr":"en"}'`).action((opts) => {
+  const locales = opts.locales.split(",").map((l) => l.trim());
+  if (!locales.includes(opts.default)) {
+    console.error(chalk.red("Error: --default locale must be listed in --locales"));
+    process.exit(1);
+  }
+  const cfg = loadConfig();
+  cfg.i18n = {
+    defaultLocale: opts.default,
+    locales,
+    routing: opts.routing
+  };
+  if (opts.fallback) {
+    try {
+      cfg.i18n.fallback = JSON.parse(opts.fallback);
+    } catch {
+      console.error(chalk.red("Error: --fallback must be valid JSON"));
+      process.exit(1);
+    }
+  }
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  i18n: " + chalk.cyan(opts.default) + " \u2192 [" + locales.join(", ") + "]");
+});
+program.command("set-markdown").description("Configure Markdown / MDX processing").option("--highlight <engine>", "shiki | prism | false", "shiki").option("--theme <theme>", "Shiki theme name", "github-dark").option("--wrap", "Enable shiki code-block word wrap").option("--no-gfm", "Disable GitHub Flavored Markdown").option("--no-smartypants", "Disable Smartypants typographic transforms").option("--remark <plugins>", "Comma-separated remark plugin package names").option("--rehype <plugins>", "Comma-separated rehype plugin package names").action((opts) => {
+  const cfg = loadConfig();
+  const hl = opts.highlight === "false" ? false : opts.highlight;
+  cfg.markdown = {
+    syntaxHighlight: hl,
+    gfm: opts.gfm !== false,
+    smartypants: opts.smartypants !== false
+  };
+  if (hl === "shiki") {
+    cfg.markdown.shikiConfig = { theme: opts.theme, wrap: !!opts.wrap };
+  }
+  if (opts.remark) cfg.markdown.remarkPlugins = opts.remark.split(",").map((r) => r.trim());
+  if (opts.rehype) cfg.markdown.rehypePlugins = opts.rehype.split(",").map((r) => r.trim());
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  Markdown: highlight=" + (hl === false ? "false" : chalk.cyan(String(hl))));
+});
+program.command("set-prefetch").description("Configure link prefetch behavior").option("--all", "Prefetch all links on the page").option("--strategy <s>", "hover | tap | viewport | load", "hover").action((opts) => {
+  const cfg = loadConfig();
+  cfg.prefetch = opts.all ? { prefetchAll: true, defaultStrategy: opts.strategy } : { defaultStrategy: opts.strategy };
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  Prefetch: " + (opts.all ? "all links, " : "") + "strategy=" + opts.strategy);
+});
+program.command("set-toolbar").description("Enable or disable the Astro dev toolbar").option("--disable", "Disable the toolbar (enabled by default)").action((opts) => {
+  const cfg = loadConfig();
+  cfg.devToolbar = { enabled: !opts.disable };
+  saveConfig(cfg);
+  console.log(chalk.green("\u2714") + "  Dev toolbar: " + (cfg.devToolbar.enabled ? chalk.green("enabled") : chalk.red("disabled")));
+});
+program.command("validate").description("Validate the current config for errors and show a summary").action(() => {
+  const cfg = loadConfig();
+  const errors = validateConfig(cfg);
+  if (errors.length === 0) {
+    console.log(chalk.green("\u2714") + "  Config is valid\n");
+    console.log("  Output:      " + chalk.yellow(cfg.output ?? "static"));
+    if (cfg.adapter) console.log("  Adapter:     " + chalk.cyan(cfg.adapter));
+    if (cfg.integrations?.length) console.log("  Integrations: " + cfg.integrations.join(", "));
+    if (cfg.i18n) console.log("  i18n:        " + cfg.i18n.defaultLocale + " / [" + cfg.i18n.locales.join(", ") + "]");
+    if (cfg.image?.service) console.log("  Image:       " + cfg.image.service);
+    if (cfg.markdown?.syntaxHighlight) console.log("  Markdown:    " + cfg.markdown.syntaxHighlight);
+  } else {
+    console.log(chalk.red("\u2716") + "  " + errors.length + " validation error(s):\n");
+    errors.forEach((e) => console.log("  " + chalk.red("\u2022") + " " + e));
+    process.exit(1);
+  }
+});
+program.command("export").description("Generate astro.config.mjs from the current CLI config").option("--out <file>", "Output file path", "astro.config.mjs").option("--dry-run", "Print to stdout without writing").action((opts) => {
+  const cfg = loadConfig();
+  const errors = validateConfig(cfg);
+  if (errors.length > 0) {
+    console.log(chalk.red("\u2716") + "  Export blocked \u2014 fix errors first:\n");
+    errors.forEach((e) => console.log("  " + chalk.red("\u2022") + " " + e));
+    process.exit(1);
+  }
+  const content = generateAstroConfig(cfg);
+  if (opts.dryRun) {
+    console.log(chalk.dim("\u2500\u2500\u2500 " + opts.out + " \u2500\u2500\u2500"));
+    console.log(content);
+  } else {
+    fs.writeFileSync(opts.out, content, "utf-8");
+    console.log(chalk.green("\u2714") + "  Written \u2192 " + chalk.cyan(opts.out));
+    console.log(chalk.dim("\n" + content));
+  }
+});
+program.command("show").description("Show the raw astro-cli.json state").action(() => {
+  const cfg = loadConfig();
+  console.log(chalk.bold("\nCurrent config (" + CONFIG_FILE + "):"));
+  console.log(chalk.dim(JSON.stringify(cfg, null, 2)));
+});
+if (process.argv.length < 3) {
+  program.help();
+}
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "astro-config-cli",
+  "version": "1.0.0",
+  "description": "CLI tool for generating and managing Astro framework configuration files",
+  "type": "module",
+  "bin": {
+    "astro-config": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "node node_modules/tsup/dist/cli-default.js",
+    "dev": "node node_modules/tsup/dist/cli-default.js --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "astro",
+    "cli",
+    "config",
+    "generator",
+    "framework"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsup": "^8.1.0",
+    "typescript": "^5.4.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/okirmio-create/cli-forge.git",
+    "directory": "astro-config-cli"
+  },
+  "homepage": "https://github.com/okirmio-create/cli-forge/tree/main/astro-config-cli",
+  "bugs": {
+    "url": "https://github.com/okirmio-create/cli-forge/issues"
+  }
+}