@daz4126/swifty 3.1.0 → 4.1.0

package/MIGRATION.md

@@ -0,0 +1,60 @@
+# Migrating to Swifty 4
+
+Swifty 4 focuses on deterministic builds, safer deployment, and explicit errors.
+
+## Requirements
+
+- Upgrade Node.js to version 22 or 24. Older Node.js releases are no longer supported.
+- Run `npm install` after upgrading so the tracked lockfile installs the new minifiers.
+
+## Clean Output and Public Files
+
+Every full build empties the output directory. Files written directly to `dist/` are removed.
+
+Move files that must pass through unchanged into `public/`:
+
+```text
+public/manifest.webmanifest -> dist/manifest.webmanifest
+public/fonts/site.woff2     -> dist/fonts/site.woff2
+```
+
+Optimized images remain cached in `.swifty-cache/`, which should not be committed.
+
+## Folder Index Pages
+
+`pages/blog/index.md` is now the content and front matter for `/blog`. It no longer creates `/blog/index` or gets treated as a child page.
+
+## Permalinks and Base Paths
+
+Use `permalink` in page front matter to override a page URL:
+
+```yaml
+permalink: /company/about.html
+```
+
+For deployment below an origin path, set `base_path` and keep `site_url` as the origin:
+
+```yaml
+site_url: https://example.com
+base_path: /project
+```
+
+The base path changes public URLs but does not add a `dist/project/` directory.
+
+## Strict Build Errors
+
+Invalid configuration, front matter, JSON/YAML data, Eta templates, partial references, images, CSS, JavaScript, or generated HTML now fail the build. Fix the path reported in the error before deploying.
+
+## Minification
+
+Swifty now uses CleanCSS, Terser, and html-minifier-terser. JavaScript is compressed but identifiers are not mangled. Set `minify`, `minify_html`, `minify_css`, or `minify_js` to `false` if source formatting must be retained.
+
+## Development Server
+
+`swifty start` now uses Swifty's built-in static server. Set `server_port` in `config.yaml` to change its default port from `3000`.
+
+## Deploy Command
+
+`swifty deploy` stages only the configured output directory. It refuses to proceed when other changes are already staged, and it does not commit source changes automatically.
+
+Commit source changes separately before deploying.

package/README.md

@@ -25,6 +25,10 @@ Swifty uses convention over configuration to make it super simple to build blazi
 - **Previous/next navigation** - Auto-generated links between sibling pages
 - **[Eta templating](https://eta.js.org/)** - Full JavaScript in templates with EJS syntax
 - **Idiomorph navigation** with optional intent prefetching for SPA-like transitions
+- **Custom permalinks and base paths** for flexible deployment URLs
+- **Public asset passthrough** for files that should be copied unchanged
+
+Requires Node.js 22 or newer. See [Migrating to Swifty 4](MIGRATION.md) when upgrading an existing site.
 
 ## Quickstart
 
@@ -48,6 +52,7 @@ your-site/
 ├── css/            # Stylesheets (auto-injected)
 ├── js/             # JavaScript (auto-injected)
 ├── images/         # Images (auto-optimized to responsive WebP)
+├── public/         # Files copied unchanged to the output root
 ├── template.html   # Base HTML template
 └── config.yaml     # Site configuration
 ```
@@ -59,14 +64,14 @@ npx swifty my-site          # Create new site in my-site/ folder
 npx swifty build            # Build static site to dist/ (for production)
 npx swifty start            # Build, watch, and serve at localhost:3000 (for development)
 npx swifty build --out dir  # Build to custom output directory
-npx swifty deploy "message" # Build, git add, commit, and push (message optional)
+npx swifty deploy "message" # Build, commit the output folder, and push
 ```
 
 ### Development vs Production
 
 - **`swifty start`** - For development. Includes live reload (auto-refreshes browser on file changes) and file watching with incremental builds for CSS/JS/images.
 - **`swifty build`** - For production deployment. Produces clean output without any development scripts.
-- **`swifty deploy "message"`** - Builds the site and commits/pushes to git in one command.
+- **`swifty deploy "message"`** - Builds the site, commits only the generated output folder, and pushes it to git.
 
 ## Documentation
 

package/package.json

@@ -1,18 +1,27 @@
 {
   "name": "@daz4126/swifty",
-  "version": "3.1.0",
-  "main": "index.js",
+  "version": "4.1.0",
+  "main": "./src/index.js",
   "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
   "bin": {
     "swifty": "./src/cli.js"
   },
+  "engines": {
+    "node": ">=22"
+  },
   "files": [
-    "src/"
+    "src/",
+    "MIGRATION.md"
   ],
   "scripts": {
     "test": "mocha",
+    "test:package": "node scripts/verify-package.js",
+    "check": "npm test && npm run test:package",
     "build": "node src/build.js",
-    "start": "node src/build.js && serve dist",
+    "start": "node src/cli.js start",
     "init": "node src/init.js",
     "watch": "node src/watcher.js"
   },
@@ -26,16 +35,17 @@
   "description": "Super Speedy Static Site Generator",
   "dependencies": {
     "chokidar": "^4.0.0",
+    "clean-css": "^5.3.3",
     "eta": "^4.5.0",
     "fs-extra": "^11.2.0",
-    "gray-matter": "^4.0.3",
     "highlight.js": "^11.11.1",
+    "html-minifier-terser": "^7.2.0",
     "js-yaml": "^4.1.0",
     "livereload": "^0.10.3",
     "marked": "^14.1.3",
     "marked-highlight": "^2.2.1",
-    "serve": "^14.2.5",
-    "sharp": "^0.33.5"
+    "sharp": "^0.33.5",
+    "terser": "^5.48.0"
   },
   "devDependencies": {
     "mocha": "^11.1.0"
@@ -45,10 +55,10 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/daz4126/swifty.git"
+    "url": "git+https://github.com/daz-codes/swifty.git"
   },
   "bugs": {
-    "url": "https://github.com/daz4126/swifty/issues"
+    "url": "https://github.com/daz-codes/swifty/issues"
   },
-  "homepage": "https://github.com/daz4126/swifty#readme"
+  "homepage": "https://github.com/daz-codes/swifty#readme"
 }

package/src/assets.js

@@ -9,6 +9,11 @@ import sharp from "sharp";
 import { dirs, defaultConfig } from "./config.js";
 import { mapLimit } from "./concurrency.js";
 import { minifyCss, minifyJs } from "./minify.js";
+import {
+  applyBasePathToCss,
+  withBasePath,
+  withoutBasePath,
+} from "./urls.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -33,7 +38,52 @@ const getBuildConcurrency = () => defaultConfig.build_concurrency || 16;
 const navigationEnabled = () => defaultConfig.morphing !== false;
 const minificationEnabled = (type) =>
   defaultConfig.minify !== false && defaultConfig[`minify_${type}`] !== false;
-const normalizeImageUrl = (url) => (url || "").split(/[?#]/)[0];
+const normalizeImageUrl = (url) =>
+  withoutBasePath((url || "").split(/[?#]/)[0]);
+
+const getImageCacheDirectory = () => {
+  const signature = crypto
+    .createHash("sha256")
+    .update(
+      JSON.stringify({
+        image_quality: defaultConfig.image_quality || 80,
+        max_image_width: defaultConfig.max_image_width || 800,
+        responsive_image_widths:
+          defaultConfig.responsive_image_widths || [320, 640, 800],
+      }),
+    )
+    .digest("hex")
+    .slice(0, 12);
+  return path.join(dirs.cache, "images", signature);
+};
+
+const prepareImageCache = async () => {
+  const cacheRoot = path.join(dirs.cache, "images");
+  const cacheDirectory = getImageCacheDirectory();
+  await fsExtra.ensureDir(cacheDirectory);
+
+  const entries = await fs.readdir(cacheRoot, { withFileTypes: true });
+  await Promise.all(
+    entries
+      .filter(
+        (entry) =>
+          entry.isDirectory() &&
+          path.join(cacheRoot, entry.name) !== cacheDirectory,
+      )
+      .map((entry) => fsExtra.remove(path.join(cacheRoot, entry.name))),
+  );
+
+  return cacheDirectory;
+};
+
+const removeStaleCachedImages = async (cacheDirectory, expectedFiles) => {
+  const files = await fs.readdir(cacheDirectory);
+  await Promise.all(
+    files
+      .filter((file) => !expectedFiles.has(file))
+      .map((file) => fsExtra.remove(path.join(cacheDirectory, file))),
+  );
+};
 
 const getResponsiveWidths = (originalWidth) => {
   const maxWidth = defaultConfig.max_image_width || 800;
@@ -62,7 +112,7 @@ const variantFilename = (filename, ext, width, outputWidth) =>
 const registerResponsiveImage = (filename, ext, variants) => {
   const basename = path.basename(filename, ext);
   const entry = {
-    src: `/images/${basename}.webp`,
+    src: withBasePath(`/images/${basename}.webp`),
     srcset: variants
       .map((variant) => `${variant.url} ${variant.width}w`)
       .join(", "),
@@ -70,7 +120,7 @@ const registerResponsiveImage = (filename, ext, variants) => {
     variants,
   };
 
-  responsiveImageMap.set(normalizeImageUrl(`/images/${filename}`), entry);
+  responsiveImageMap.set(normalizeImageUrl(withBasePath(`/images/${filename}`)), entry);
   responsiveImageMap.set(normalizeImageUrl(entry.src), entry);
 };
 
@@ -91,7 +141,7 @@ const getNavigationAssetName = async (filename = "swifty-navigation.js") => {
 
 const getNavigationScriptSrc = async () => {
   if (!navigationEnabled()) return "";
-  return `/swifty/${await getNavigationAssetName()}`;
+  return withBasePath(`/swifty/${await getNavigationAssetName()}`);
 };
 
 const isDestinationFresh = async (source, destination) => {
@@ -115,22 +165,37 @@ const copyIfStale = async (source, destination) => {
   return true;
 };
 
-const optimizeImageVariantToWebp = async (source, destination, width) => {
-  if (await isDestinationFresh(source, destination)) {
-    return false;
+const optimizeImageVariantToWebp = async (
+  source,
+  destination,
+  cacheDestination,
+  width,
+) => {
+  let optimized = false;
+
+  if (!(await isDestinationFresh(source, cacheDestination))) {
+    const imageQuality = defaultConfig.image_quality || 80;
+    await fsExtra.ensureDir(path.dirname(cacheDestination));
+
+    await sharp(source)
+      .resize({ width })
+      .toFormat("webp", { quality: imageQuality })
+      .toFile(cacheDestination);
+    optimized = true;
   }
 
-  const imageQuality = defaultConfig.image_quality || 80;
-
-  await sharp(source)
-    .resize({ width })
-    .toFormat("webp", { quality: imageQuality })
-    .toFile(destination);
-
-  return true;
+  await copyIfStale(cacheDestination, destination);
+  return optimized;
 };
 
-const optimizeImageToWebp = async (source, imagesFolder, filename, ext) => {
+const optimizeImageToWebp = async (
+  source,
+  imagesFolder,
+  cacheDirectory,
+  filename,
+  ext,
+  expectedCacheFiles,
+) => {
   const metadata = await sharp(source).metadata();
   const originalWidth = metadata.width || 0;
   const maxWidth = defaultConfig.max_image_width || 800;
@@ -138,17 +203,24 @@ const optimizeImageToWebp = async (source, imagesFolder, filename, ext) => {
     originalWidth > 0 ? Math.min(originalWidth, maxWidth) : maxWidth;
   const variants = getResponsiveWidths(originalWidth).map((width) => {
     const file = variantFilename(filename, ext, width, outputWidth);
+    expectedCacheFiles?.add(file);
     return {
       width,
       file,
-      url: `/images/${file}`,
+      url: withBasePath(`/images/${file}`),
       destination: path.join(imagesFolder, file),
+      cacheDestination: path.join(cacheDirectory, file),
     };
   });
 
   const results = await Promise.all(
     variants.map((variant) =>
-      optimizeImageVariantToWebp(source, variant.destination, variant.width),
+      optimizeImageVariantToWebp(
+        source,
+        variant.destination,
+        variant.cacheDestination,
+        variant.width,
+      ),
     ),
   );
 
@@ -163,12 +235,21 @@ const optimizeImageToWebp = async (source, imagesFolder, filename, ext) => {
 
 const processTextAsset = async (source, destination, type) => {
   const content = await fs.readFile(source, "utf-8");
-  const nextContent =
-    type === "css" && minificationEnabled("css")
-      ? minifyCss(content)
-      : type === "js" && minificationEnabled("js")
-        ? minifyJs(content)
-        : content;
+  let nextContent = content;
+
+  try {
+    if (type === "css" && minificationEnabled("css")) {
+      nextContent = minifyCss(applyBasePathToCss(content));
+    } else if (type === "js" && minificationEnabled("js")) {
+      nextContent = await minifyJs(content);
+    } else if (type === "css") {
+      nextContent = applyBasePathToCss(content);
+    }
+  } catch (error) {
+    throw new Error(`Unable to minify ${source}: ${error.message}`, {
+      cause: error,
+    });
+  }
 
   try {
     const currentContent = await fs.readFile(destination, "utf-8");
@@ -236,6 +317,9 @@ const copyNavigationAssets = async (outputDir = dirs.dist) => {
 };
 
 const copyAssets = async (outputDir = dirs.dist) => {
+  if (await fsExtra.pathExists(dirs.public)) {
+    await fsExtra.copy(dirs.public, outputDir, { overwrite: true });
+  }
   await ensureAndCopy(
     dirs.css,
     path.join(outputDir, "css"),
@@ -249,11 +333,14 @@ async function optimizeImages(outputDir = dirs.dist) {
 
   try {
     if (!(await fsExtra.pathExists(dirs.images))) {
+      await fsExtra.remove(path.join(dirs.cache, "images"));
       console.log(`No ${path.basename(dirs.images)} found in ${dirs.images}`);
       return;
     }
 
     const imagesFolder = path.join(outputDir, "images");
+    const cacheDirectory = await prepareImageCache();
+    const expectedCacheFiles = new Set();
     await fsExtra.ensureDir(imagesFolder);
 
     const files = await fs.readdir(dirs.images);
@@ -278,8 +365,10 @@ async function optimizeImages(outputDir = dirs.dist) {
         const optimized = await optimizeImageToWebp(
           filePath,
           imagesFolder,
+          cacheDirectory,
           file,
           ext,
+          expectedCacheFiles,
         );
         if (optimized) {
           console.log(`Optimized ${file}`);
@@ -287,8 +376,11 @@ async function optimizeImages(outputDir = dirs.dist) {
       },
       getBuildConcurrency(),
     );
+    await removeStaleCachedImages(cacheDirectory, expectedCacheFiles);
   } catch (error) {
-    console.error("Error optimizing images:", error);
+    throw new Error(`Unable to optimize images: ${error.message}`, {
+      cause: error,
+    });
   }
 }
 const generateAssetImports = async (dir, tagTemplate, validExts) => {
@@ -309,25 +401,25 @@ const generateAssetImports = async (dir, tagTemplate, validExts) => {
 const getCssImports = () =>
   generateAssetImports(
     dirs.css,
-    (file, mtime) => `<link rel="stylesheet" href="/css/${file}?v=${mtime}" />`,
+    (file, mtime) => `<link rel="stylesheet" href="${withBasePath(`/css/${file}`)}?v=${mtime}" />`,
     validExtensions.css,
   );
 const getJsImports = () =>
   generateAssetImports(
     dirs.js,
-    (file, mtime) => `<script src="/js/${file}?v=${mtime}"></script>`,
+    (file, mtime) => `<script src="${withBasePath(`/js/${file}`)}?v=${mtime}"></script>`,
     validExtensions.js,
   );
 const getCssPreloads = () =>
   generateAssetImports(
     dirs.css,
-    (file, mtime) => `<link rel="preload" href="/css/${file}?v=${mtime}" as="style" />`,
+    (file, mtime) => `<link rel="preload" href="${withBasePath(`/css/${file}`)}?v=${mtime}" as="style" />`,
     validExtensions.css,
   );
 const getJsPreloads = () =>
   generateAssetImports(
     dirs.js,
-    (file, mtime) => `<link rel="preload" href="/js/${file}?v=${mtime}" as="script" />`,
+    (file, mtime) => `<link rel="preload" href="${withBasePath(`/js/${file}`)}?v=${mtime}" as="script" />`,
     validExtensions.js,
   );
 
@@ -359,6 +451,7 @@ const optimizeSingleImage = async (filePath, outputDir = dirs.dist) => {
   const filename = path.basename(filePath);
   const ext = path.extname(filePath).toLowerCase();
   const imagesFolder = path.join(outputDir, "images");
+  const cacheDirectory = await prepareImageCache();
 
   await fsExtra.ensureDir(imagesFolder);
 
@@ -374,6 +467,7 @@ const optimizeSingleImage = async (filePath, outputDir = dirs.dist) => {
   const optimized = await optimizeImageToWebp(
     filePath,
     imagesFolder,
+    cacheDirectory,
     filename,
     ext,
   );
@@ -394,4 +488,5 @@ export {
   optimizeSingleImage,
   getNavigationScriptSrc,
   getResponsiveImage,
+  getImageCacheDirectory,
 };

package/src/build.js

@@ -1,22 +1,54 @@
 import { argv } from "process";
+import path from "path";
 import { fileURLToPath } from "url";
+
+import fsExtra from "fs-extra";
+
 import { copyAssets, optimizeImages } from "./assets.js";
 import { generatePages, createPages, addLinks } from "./pages.js";
 import { generateRssFeeds } from "./rss.js";
 import { generateSeoFiles } from "./sitemap.js";
-import { dirs } from "./config.js";
+import { baseDir, dirs } from "./config.js";
+import { clearDataCache } from "./data.js";
+import { resetCaches } from "./layout.js";
+import { clearCache as clearPartialCache } from "./partials.js";
+
+const prepareOutputDirectory = async (outputDir) => {
+  const projectPath = path.resolve(baseDir);
+  const outputPath = path.resolve(baseDir, outputDir);
+  const outputContainsProject =
+    projectPath === outputPath || projectPath.startsWith(`${outputPath}${path.sep}`);
+  const sourceDirectories = Object.entries(dirs)
+    .filter(([name]) => name !== "dist")
+    .map(([, directory]) => path.resolve(directory));
+  const outputOverlapsSource = sourceDirectories.some(
+    (directory) =>
+      outputPath === directory || outputPath.startsWith(`${directory}${path.sep}`),
+  );
+
+  if (outputContainsProject || outputOverlapsSource) {
+    throw new Error(`Refusing to empty unsafe output directory: ${outputPath}`);
+  }
+
+  await fsExtra.emptyDir(outputPath);
+  return outputPath;
+};
 
 export default async function build(outputDir = dirs.dist) {
   const startTime = performance.now();
   console.log("🚀 Starting build...");
+  const resolvedOutputDir = await prepareOutputDirectory(outputDir);
+  clearDataCache();
+  clearPartialCache();
   
   const copyStart = performance.now();
-  await copyAssets(outputDir);
+  await copyAssets(resolvedOutputDir);
   const copyTime = performance.now() - copyStart;
   console.log(`📁 Assets copied in ${(copyTime / 1000).toFixed(2)}s`);
+  await resetCaches();
   
   const imageStart = performance.now();
-  await optimizeImages(outputDir);
+  await optimizeImages(resolvedOutputDir);
   const imageTime = performance.now() - imageStart;
   console.log(`🖼️  Images optimized in ${(imageTime / 1000).toFixed(2)}s`);
   
@@ -31,17 +63,17 @@ export default async function build(outputDir = dirs.dist) {
   console.log(`🔗 Links added in ${(linksTime / 1000).toFixed(2)}s`);
   
   const createStart = performance.now();
-  await createPages(pages, outputDir);
+  await createPages(pages, resolvedOutputDir);
   const createTime = performance.now() - createStart;
   console.log(`✨ Pages created in ${(createTime / 1000).toFixed(2)}s`);
   
   const rssStart = performance.now();
-  await generateRssFeeds(pages, outputDir);
+  await generateRssFeeds(pages, resolvedOutputDir);
   const rssTime = performance.now() - rssStart;
   console.log(`📡 RSS feeds generated in ${(rssTime / 1000).toFixed(2)}s`);
 
   const seoStart = performance.now();
-  await generateSeoFiles(pages, outputDir);
+  await generateSeoFiles(pages, resolvedOutputDir);
   const seoTime = performance.now() - seoStart;
   console.log(`🧭 SEO files generated in ${(seoTime / 1000).toFixed(2)}s`);
   
@@ -70,6 +102,8 @@ export default async function build(outputDir = dirs.dist) {
   }
 }
 
+export { prepareOutputDirectory };
+
 // Run the build when invoked directly (e.g. `npm run build`, `npm start`),
 // not when imported as a module (e.g. by cli.js).
 if (argv[1] && fileURLToPath(import.meta.url) === argv[1]) {

package/src/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
-import { spawn, execSync } from "child_process";
+import { execFileSync, spawnSync } from "child_process";
+import { fileURLToPath } from "url";
 
 const args = process.argv.slice(2);
 let outDir = "dist"; // default
@@ -14,7 +15,46 @@ if (outIndex !== -1 && args[outIndex + 1]) {
 // Pass outDir as an environment variable too (optional, still useful)
 process.env.OUT_DIR = outDir;
 
-const reservedCommands = ["build", "start", "watch", "deploy"];
+const commitAndPushOutput = (
+  outputDir,
+  commitMessage,
+  { execFile = execFileSync, spawnFile = spawnSync } = {},
+) => {
+  const existingDiff = spawnFile("git", ["diff", "--cached", "--quiet"], {
+    stdio: "ignore",
+  });
+  if (existingDiff.error) throw existingDiff.error;
+  if (existingDiff.status === 1) {
+    throw new Error("Refusing to deploy while unrelated changes are already staged.");
+  }
+  if (existingDiff.status !== 0) {
+    throw new Error(
+      `Unable to inspect staged changes (git exited ${existingDiff.status}).`,
+    );
+  }
+
+  console.log(`Adding generated output from ${outputDir} to git...`);
+  execFile("git", ["add", "--", outputDir], { stdio: "inherit" });
+
+  const diffResult = spawnFile("git", ["diff", "--cached", "--quiet"], {
+    stdio: "ignore",
+  });
+  if (diffResult.error) throw diffResult.error;
+  if (diffResult.status === 0) {
+    console.log("No generated output changes to deploy.");
+    return false;
+  }
+  if (diffResult.status !== 1) {
+    throw new Error(`Unable to inspect staged changes (git exited ${diffResult.status}).`);
+  }
+
+  console.log("Committing generated output...");
+  execFile("git", ["commit", "-m", commitMessage], { stdio: "inherit" });
+
+  console.log("Pushing to remote...");
+  execFile("git", ["push"], { stdio: "inherit" });
+  return true;
+};
 
 async function main() {
   const command = args[0];
@@ -52,8 +92,8 @@ async function main() {
         watcher.default(outDir);
       }
 
-      // Start the server (blocking)
-      spawn("npx", ["serve", outDir], { stdio: "inherit" });
+      const server = await import("./server.js");
+      await server.default(outDir);
       break;
     }
     case "watch": {
@@ -64,7 +104,11 @@ async function main() {
       break;
     }
     case "deploy": {
-      const commitMessage = args[1] || "Deploying latest build";
+      const commandArgs = args.slice(1).filter((arg, index, values) => {
+        if (arg === "--out") return false;
+        return index === 0 || values[index - 1] !== "--out";
+      });
+      const commitMessage = commandArgs[0] || "Deploying latest build";
 
       // Build the site
       const build = await import("./build.js");
@@ -74,18 +118,8 @@ async function main() {
 
       // Git operations
       try {
-        console.log("Adding files to git...");
-        execSync("git add .", { stdio: "inherit" });
-
-        console.log("Committing changes...");
-        execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
-          stdio: "inherit",
-        });
-
-        console.log("Pushing to remote...");
-        execSync("git push", { stdio: "inherit" });
-
-        console.log("Deployed successfully!");
+        const deployed = commitAndPushOutput(outDir, commitMessage);
+        if (deployed) console.log("Deployed successfully!");
       } catch (error) {
         console.error("Deploy failed:", error.message);
         process.exit(1);
@@ -104,4 +138,11 @@ async function main() {
   }
 }
 
-main();
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  main().catch((error) => {
+    console.error(`Swifty failed: ${error.message}`);
+    process.exitCode = 1;
+  });
+}
+
+export { commitAndPushOutput, main };