@abcnews/aunty 17.0.0-next.4 → 17.0.0-next.6

package/dist/bin/aunty.js

@@ -0,0 +1,1782 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/util.ts
+import { realpathSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import pc from "picocolors";
+function isLocalDevelopment() {
+  try {
+    const realDir = realpathSync(import.meta.dirname);
+    return !realDir.includes("node_modules");
+  } catch {
+    return false;
+  }
+}
+async function loadJson(filePath) {
+  try {
+    const content = await readFile(filePath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function formatSize(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let unitIndex = 0;
+  let size = bytes;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  const formatted = `${size.toFixed(1)}${units[unitIndex]}`;
+  if (bytes >= 1024 * 1024) {
+    return pc.yellow(formatted);
+  }
+  return pc.green(formatted);
+}
+async function findProjectDetails(currentDir) {
+  if (currentDir === path.parse(currentDir).root) {
+    const { log: log8 } = await import("@clack/prompts");
+    log8.error(
+      `Could not find ${pc.cyan("package.json")} in this or any parent directory.`
+    );
+    return null;
+  }
+  const pkgPath2 = path.join(currentDir, "package.json");
+  const pkg2 = await loadJson(pkgPath2);
+  if (pkg2) {
+    return { root: currentDir, pkg: pkg2 };
+  }
+  return findProjectDetails(path.dirname(currentDir));
+}
+async function runBuild(options = {}) {
+  const { stdio = "inherit" } = options;
+  const details = await findProjectDetails(process.cwd());
+  if (!details) {
+    throw new Error("Could not find project details.");
+  }
+  const { pkg: pkg2 } = details;
+  if (!pkg2.scripts?.build) {
+    throw new Error("Could not find a build script in package.json.");
+  }
+  const { $: $10 } = await import("zx");
+  await $10({ stdio })`npm run build`;
+}
+var init_util = __esm({
+  "src/lib/util.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/constants.ts
+var BUILD_DIRECTORY_NAME, FTP_PROJECTS_PATH, PUBLIC_PROJECTS_URL;
+var init_constants = __esm({
+  "src/lib/constants.ts"() {
+    "use strict";
+    BUILD_DIRECTORY_NAME = "dist";
+    FTP_PROJECTS_PATH = "/www/res/sites/news-projects/";
+    PUBLIC_PROJECTS_URL = "https://www.abc.net.au/res/sites/news-projects/";
+  }
+});
+
+// src/lib/ftp.ts
+import ftp from "basic-ftp";
+import os from "node:os";
+import path2 from "node:path";
+import slugify from "slugify";
+async function getCredentials() {
+  const credentials = await loadJson(CREDENTIALS_PATH);
+  const contentftp = credentials?.contentftp;
+  if (!contentftp) {
+    throw new Error(
+      `Credentials file not found or missing 'contentftp' at ${CREDENTIALS_PATH}`
+    );
+  }
+  return contentftp;
+}
+async function isProjectNameAndVersionAvailable(projectName, version2, ftpClient) {
+  const client = ftpClient || new FtpClient();
+  try {
+    if (!ftpClient) {
+      await client.connect(5e3);
+    }
+    const nameSlug = slugify(
+      projectName,
+      { strict: true }
+    );
+    const remoteDir = version2 ? path2.join(FTP_PROJECTS_PATH, nameSlug, version2, "/") : path2.join(FTP_PROJECTS_PATH, nameSlug, "/");
+    const exists = await client.exists(remoteDir);
+    return exists ? "exists" : "available";
+  } catch {
+    return "available";
+  } finally {
+    if (!ftpClient) {
+      client.close();
+    }
+  }
+}
+async function testFtpConnection(timeout = 5e3) {
+  const ftpClient = new FtpClient();
+  try {
+    await ftpClient.connect(timeout);
+    return { success: true, ftpClient };
+  } catch (err) {
+    ftpClient.close();
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+var CREDENTIALS_PATH, FtpClient;
+var init_ftp = __esm({
+  "src/lib/ftp.ts"() {
+    "use strict";
+    init_util();
+    init_constants();
+    CREDENTIALS_PATH = path2.resolve(os.homedir(), ".abc-credentials");
+    FtpClient = class {
+      ftpClient;
+      ensuredDirs;
+      credentialsPromise;
+      constructor(verbose = false) {
+        this.ftpClient = new ftp.Client();
+        this.ensuredDirs = /* @__PURE__ */ new Set();
+        this.credentialsPromise = getCredentials();
+        if (verbose) {
+          this.ftpClient.ftp.verbose = true;
+        }
+      }
+      /**
+       * Connect to the FTP server
+       */
+      async connect(timeout = 5e3) {
+        this.ftpClient.ftp.timeout = timeout;
+        const credentials = await this.credentialsPromise;
+        await this.ftpClient.access({
+          host: credentials.host,
+          user: credentials.username,
+          password: credentials.password,
+          port: Number(credentials.port) || 21,
+          secure: false
+        });
+      }
+      /**
+       * Check if a directory exists on the remote
+       */
+      async exists(remotePath) {
+        try {
+          const parent = path2.dirname(remotePath);
+          const name = path2.basename(remotePath);
+          const list = await this.ftpClient.list(parent);
+          return list.some((item) => item.name === name);
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Upload a directory to a remote path
+       */
+      async uploadDir(localDir, remoteDir, onProgress) {
+        if (onProgress) {
+          this.ftpClient.trackProgress(onProgress);
+        }
+        await this.ftpClient.ensureDir(remoteDir);
+        await this.ftpClient.uploadFromDir(localDir);
+      }
+      /**
+       * Ensure a remote directory exists (with local caching)
+       */
+      async ensureDir(remoteDir) {
+        if (this.ensuredDirs.has(remoteDir)) return;
+        await this.ftpClient.ensureDir(remoteDir);
+        this.ensuredDirs.add(remoteDir);
+      }
+      /**
+       * Close the connection
+       */
+      close() {
+        this.ftpClient.close();
+      }
+    };
+  }
+});
+
+// src/lib/terminal.ts
+import { spinner } from "@clack/prompts";
+import pc2 from "picocolors";
+var getColorFn, styleLogoLine, getGradientLogo, getHeader, spin, printDevColours;
+var init_terminal = __esm({
+  "src/lib/terminal.ts"() {
+    "use strict";
+    getColorFn = (colourName) => {
+      switch (colourName) {
+        case "blue":
+          return pc2.blue;
+        case "green":
+          return pc2.green;
+        case "magenta":
+          return pc2.magenta;
+        case "yellow":
+          return pc2.yellow;
+        case "cyan":
+          return pc2.cyan;
+        case "red":
+          return pc2.red;
+        default:
+          return pc2.dim;
+      }
+    };
+    styleLogoLine = (text2, colourName, dimmedIndices) => {
+      const rainbowColors = [pc2.red, pc2.yellow, pc2.green, pc2.cyan, pc2.blue, pc2.magenta];
+      const isRainbow = colourName === "rainbow";
+      const singleColorFn = isRainbow ? null : getColorFn(colourName);
+      let rainbowIndex = 0;
+      return [...text2].map((char, index2) => {
+        if (char === " ") return char;
+        const colorFn = isRainbow ? rainbowColors[rainbowIndex++ % rainbowColors.length] : singleColorFn;
+        const colored = colorFn(char);
+        return dimmedIndices.includes(index2) ? pc2.dim(colored) : colored;
+      }).join("");
+    };
+    getGradientLogo = (colour = "rainbow") => {
+      return {
+        line1: styleLogoLine(" \u28FE\u28B7\u287E\u28B7\u287E\u28F7 ", colour, [2, 5]),
+        line2: styleLogoLine(" \u28BF\u287E\u28B7\u287E\u28B7\u287F ", colour, [3, 4])
+      };
+    };
+    getHeader = (line1 = "", line2 = "", options = {}) => {
+      const prepend = typeof options === "string" ? options : options.prepend ?? `${pc2.gray("\u2502")}`;
+      const colour = typeof options === "string" ? "rainbow" : options.colour ?? "rainbow";
+      const { line1: logoLine1, line2: logoLine2 } = getGradientLogo(colour);
+      return [
+        "",
+        `${prepend}${logoLine1} ${line1}`,
+        `${prepend}${logoLine2} ${pc2.bold(line2)}`
+      ].join("\n");
+    };
+    spin = (text2 = "", frames = [
+      "\u28CF\u2800\u2800",
+      "\u285F\u2800\u2800",
+      "\u281F\u2804\u2800",
+      "\u281B\u2844\u2800",
+      "\u2819\u28C4\u2800",
+      "\u2818\u28E4\u2800",
+      "\u2810\u28E4\u2802",
+      "\u2800\u28E4\u2803",
+      "\u2800\u28E0\u280B",
+      "\u2800\u28A0\u281B",
+      "\u2800\u2820\u283B",
+      "\u2800\u2800\u28BB",
+      "\u2800\u2800\u28F9",
+      "\u2800\u2800\u28FC",
+      "\u2800\u2810\u28F4",
+      "\u2800\u2818\u28E4",
+      "\u2800\u2819\u28C4",
+      "\u2800\u281B\u2844",
+      "\u2820\u281B\u2804",
+      "\u28A0\u281B\u2800",
+      "\u28E0\u280B\u2800",
+      "\u28E4\u2803\u2800",
+      "\u28E6\u2802\u2800",
+      "\u28E7\u2800\u2800"
+    ]) => {
+      const s = spinner({ frames });
+      s.start(text2);
+      return s;
+    };
+    printDevColours = () => {
+      const testColours = [
+        "rainbow",
+        "blue",
+        "green",
+        "cyan",
+        "yellow",
+        "magenta",
+        "red"
+      ];
+      testColours.forEach((colour) => {
+        console.log(`
+--- ${colour.toUpperCase()} ---`);
+        console.log(
+          getHeader("aunty", `dev-mode (${colour})`, {
+            colour
+          })
+        );
+      });
+    };
+  }
+});
+
+// src/commands/deploy/fs.ts
+import fs from "node:fs/promises";
+import path3 from "node:path";
+async function getFileInventory(dirPath, baseDir = dirPath) {
+  const inventory = [];
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path3.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      inventory.push(...await getFileInventory(fullPath, baseDir));
+    } else if (entry.isFile()) {
+      const stats = await fs.stat(fullPath);
+      inventory.push({
+        path: fullPath,
+        relPath: path3.relative(baseDir, fullPath),
+        size: stats.size
+      });
+    }
+  }
+  return inventory;
+}
+var init_fs = __esm({
+  "src/commands/deploy/fs.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/deploy/index.ts
+import { intro, outro, confirm, log, cancel, isCancel } from "@clack/prompts";
+import path4 from "node:path";
+import pc3 from "picocolors";
+import slugify2 from "slugify";
+async function run(options = {}) {
+  if (!options.skipHeader) {
+    intro(
+      getHeader(
+        pc3.dim("aunty"),
+        `deploy${options.dryRun ? ` ${pc3.cyan("[dry]")}` : ""}`,
+        { colour: "red" }
+      )
+    );
+  }
+  const details = await findProjectDetails(process.cwd());
+  if (!details) return 1;
+  const { root: projectRoot, pkg: config } = details;
+  const { name, version: version2 } = config;
+  if (!name || !version2) {
+    cancel("Missing name or version in package.json");
+    return 1;
+  }
+  const localDir = path4.resolve(
+    projectRoot,
+    options.buildDir || BUILD_DIRECTORY_NAME
+  );
+  const nameSlug = slugify2(
+    name,
+    { strict: true }
+  );
+  const targetFolder = options.destDir || version2;
+  const remoteDir = path4.join(FTP_PROJECTS_PATH, nameSlug, targetFolder, "/");
+  const publicUrl = `${PUBLIC_PROJECTS_URL}${nameSlug}/${targetFolder}/`;
+  let inventory;
+  try {
+    inventory = await getFileInventory(localDir);
+  } catch {
+    cancel(
+      `Build directory not found at ${pc3.cyan(localDir)}. Have you run the build command?`
+    );
+    return 1;
+  }
+  if (inventory.length === 0) {
+    cancel(`Build directory is empty! Nothing to deploy.`);
+    return 1;
+  }
+  const list = inventory.map(
+    (f) => `  ${pc3.dim(f.relPath)} (${formatSize(f.size)})`
+  ).join("\n");
+  log.step(`Found ${pc3.bold(inventory.length)} files to deploy:
+${list}`);
+  if (options.dryRun) {
+    outro(pc3.green("Dry run complete. No files were uploaded."));
+    return 0;
+  }
+  const ftpClient = new FtpClient();
+  try {
+    await ftpClient.connect();
+  } catch (err) {
+    log.error(
+      `FTP connection failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return 1;
+  }
+  const exists = await ftpClient.exists(remoteDir);
+  if (exists && !options.force) {
+    ftpClient.close();
+    const shouldOverwrite = await confirm({
+      message: `${pc3.red(`Directory ${pc3.bold(remoteDir)} already exists.`)} Overwrite?`,
+      initialValue: false
+    });
+    if (!shouldOverwrite || isCancel(shouldOverwrite)) {
+      cancel("Deploy cancelled.");
+      return 0;
+    }
+    await ftpClient.connect();
+  } else if (!exists) {
+    await ftpClient.ensureDir(remoteDir);
+  } else if (options.force) {
+    log.info(pc3.yellow("Force flag used. Overwriting remote directory."));
+  }
+  const uploadSpinner = spin("Uploading files...");
+  let uploadedCount = 0;
+  let currentFile = "";
+  const totalFilesStr = inventory.length.toString();
+  try {
+    await ftpClient.uploadDir(localDir, remoteDir, (info) => {
+      if (info.name !== currentFile) {
+        uploadedCount++;
+        currentFile = info.name;
+        const countStr = uploadedCount.toString().padStart(totalFilesStr.length, " ");
+        uploadSpinner.message(`${countStr}/${totalFilesStr} ${info.name}`);
+      }
+    });
+    uploadSpinner.stop(`Upload finished`);
+  } catch (err) {
+    uploadSpinner.cancel("Upload failed");
+    ftpClient.close();
+    throw err;
+  }
+  ftpClient.close();
+  outro(`${pc3.bold("Released to:")} ${pc3.cyan(publicUrl)}`);
+  return 0;
+}
+var init_deploy = __esm({
+  "src/commands/deploy/index.ts"() {
+    "use strict";
+    init_ftp();
+    init_util();
+    init_terminal();
+    init_constants();
+    init_fs();
+  }
+});
+
+// src/lib/git.ts
+import { $ } from "zx";
+import { log as log2 } from "@clack/prompts";
+async function isAccessible() {
+  try {
+    await $`git --version`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isInsideRepo() {
+  try {
+    await $`git rev-parse --is-inside-work-tree`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isClean() {
+  const result = await $`git status --porcelain`.quiet();
+  return result.stdout.trim() === "";
+}
+async function getBranch() {
+  const result = await $`git branch --show-current`.quiet();
+  return result.stdout.trim();
+}
+async function isBehindRemote() {
+  await $`git fetch`.quiet();
+  const result = await $`git rev-list --count HEAD..@{u}`.quiet();
+  return Number(result.stdout.trim()) > 0;
+}
+async function hasRemote() {
+  try {
+    await $`git rev-parse --abbrev-ref @{u}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function rollback(version2) {
+  try {
+    const lastCommitMsg = (await $`git log -1 --pretty=%B`.quiet()).stdout.trim();
+    if (lastCommitMsg !== `v${version2}` && lastCommitMsg !== version2) {
+      log2.warn(
+        `Abort rollback: Last commit message "${lastCommitMsg}" does not match version v${version2}.`
+      );
+      return;
+    }
+    log2.info("Rolling back local version bump commit and tag...");
+    await $`git tag -d v${version2}`;
+    await $`git reset --hard HEAD~1`;
+    log2.info(
+      "This release has been rolled back, your workspace is clean to try again."
+    );
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    log2.error(`Failed to completely roll back: ${errorMessage}`);
+  }
+}
+var init_git = __esm({
+  "src/lib/git.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/release-check/index.ts
+import { intro as intro2 } from "@clack/prompts";
+import pc4 from "picocolors";
+async function run2(options = {}) {
+  if (!options.skipHeader) {
+    intro2(getHeader(pc4.dim("aunty"), "release-check", { colour: "magenta" }));
+  }
+  const s = spin("Performing pre-release checks...");
+  const checks = [];
+  const gitAccessible = await isAccessible();
+  const insideRepo = gitAccessible ? await isInsideRepo() : false;
+  if (!gitAccessible) {
+    checks.push(
+      renderError(
+        "Git is not accessible (please ensure git is installed and Xcode/licenses are accepted)"
+      )
+    );
+  } else if (!insideRepo) {
+    checks.push(renderError("The current directory is not a git repository"));
+  } else {
+    checks.push(
+      await isClean() ? renderSuccess("Changes are all committed") : renderError("You have uncommitted changes")
+    );
+    const branch = await getBranch();
+    const isMain = branch === "main";
+    checks.push(
+      isMain ? renderSuccess("On the release branch (main)") : renderError(
+        `You are on the ${pc4.bold(branch)} branch (releases must be from ${pc4.bold("main")})`
+      )
+    );
+    if (await hasRemote()) {
+      checks.push(
+        !await isBehindRemote() ? renderSuccess("Synchronised with remote branch") : renderError("Your local branch is behind the remote")
+      );
+    } else {
+      checks.push(
+        renderError(
+          "Your local branch has no remote tracking branch. Try running git push."
+        )
+      );
+    }
+  }
+  s.message("Testing FTP connection...");
+  const {
+    success: ftpSuccess,
+    error: ftpError,
+    ftpClient
+  } = await testFtpConnection(5e3);
+  checks.push(
+    ftpSuccess ? renderSuccess("FTP is reachable") : renderError(`FTP connection failed: ${ftpError}`)
+  );
+  if (ftpSuccess) {
+    if (options.projectName && options.version) {
+      s.message("Checking project version availability...");
+      const availability = await isProjectNameAndVersionAvailable(
+        options.projectName,
+        options.version,
+        ftpClient
+      );
+      if (availability === "exists") {
+        checks.push(
+          renderError(
+            `Project version ${pc4.bold(options.version)} already exists on the FTP server`
+          )
+        );
+      } else if (availability === "error") {
+        checks.push(
+          renderError(
+            "Failed to check project version availability on the FTP server"
+          )
+        );
+      } else {
+        checks.push(renderSuccess("Project version is available"));
+      }
+    }
+    ftpClient?.close();
+  }
+  s.message("Running npm run build check...");
+  try {
+    await runBuild({ stdio: "pipe" });
+    checks.push(renderSuccess("Project built successfully"));
+  } catch (err) {
+    if (err.stdout) {
+      process.stdout.write(err.stdout);
+    }
+    if (err.stderr) {
+      process.stderr.write(err.stderr);
+    }
+    checks.push(
+      renderError(
+        `Project build failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+  }
+  const haveChecksFailed = checks.some((c) => c.includes("\u2718"));
+  if (haveChecksFailed) {
+    s.cancel("Release checks failed");
+  } else {
+    s.stop("Release checks passed");
+  }
+  if (haveChecksFailed || !options.quiet) {
+    if (checks.length > 0) {
+      console.log(`${pc4.gray("\u2502")}`);
+      checks.forEach((check) => console.log(check));
+      console.log(`${pc4.gray("\u2502")}`);
+    }
+  }
+  if (haveChecksFailed) {
+    return 1;
+  }
+  return 0;
+}
+var renderSuccess, renderError;
+var init_release_check = __esm({
+  "src/commands/release-check/index.ts"() {
+    "use strict";
+    init_terminal();
+    init_ftp();
+    init_util();
+    init_git();
+    renderSuccess = (message) => `${pc4.gray("\u2502")}  ${pc4.green("\u2714")}  ${pc4.bold(message)}`;
+    renderError = (message) => `${pc4.gray("\u2502")}  ${pc4.red("\u2718")}  ${pc4.bold(message)}`;
+  }
+});
+
+// src/lib/semver.ts
+import semver from "semver";
+function getVersionOptions(currentVersion) {
+  const prereleaseParts = semver.prerelease(currentVersion);
+  const isPrerelease = !!prereleaseParts;
+  const preid = prereleaseParts && typeof prereleaseParts[0] === "string" ? prereleaseParts[0] : PRERELEASE_LABEL;
+  if (isPrerelease) {
+    const releaseVersion = semver.inc(currentVersion, "patch");
+    const nextPrerelease = semver.inc(currentVersion, "prerelease", preid);
+    return [
+      { value: releaseVersion, label: `Release (${releaseVersion})` },
+      { value: nextPrerelease, label: `Prerelease (${nextPrerelease})` }
+    ];
+  }
+  const patch = semver.inc(currentVersion, "patch");
+  const minor = semver.inc(currentVersion, "minor");
+  const major = semver.inc(currentVersion, "major");
+  const prepatch = semver.inc(currentVersion, "prepatch", PRERELEASE_LABEL);
+  const preminor = semver.inc(currentVersion, "preminor", PRERELEASE_LABEL);
+  const premajor = semver.inc(currentVersion, "premajor", PRERELEASE_LABEL);
+  return [
+    { value: patch, label: `Patch (${patch})` },
+    { value: minor, label: `Minor (${minor})` },
+    { value: major, label: `Major (${major})` },
+    { value: prepatch, label: `Prerelease Patch (${prepatch})` },
+    { value: preminor, label: `Prerelease Minor (${preminor})` },
+    { value: premajor, label: `Prerelease Major (${premajor})` }
+  ];
+}
+var PRERELEASE_LABEL;
+var init_semver = __esm({
+  "src/lib/semver.ts"() {
+    "use strict";
+    PRERELEASE_LABEL = "prerelease";
+  }
+});
+
+// src/commands/release/index.ts
+import { intro as intro3, outro as outro2, select, cancel as cancel2, isCancel as isCancel2, log as log3 } from "@clack/prompts";
+import pc5 from "picocolors";
+import semver2 from "semver";
+import { $ as $2 } from "zx";
+async function run3(options = {}) {
+  intro3(getHeader(pc5.dim("aunty"), "release", { colour: "yellow" }));
+  const details = await findProjectDetails(process.cwd());
+  if (!details) {
+    return 1;
+  }
+  const { pkg: pkg2 } = details;
+  const currentVersion = pkg2.version;
+  if (!currentVersion) {
+    cancel2("No version found in package.json, please set up your project.");
+    return 1;
+  }
+  if (!semver2.valid(currentVersion)) {
+    cancel2(
+      `Current version ${pc5.bold(currentVersion)} is not a valid semver version`
+    );
+    return 1;
+  }
+  let nextVersion = void 0;
+  if (options.version) {
+    if (!semver2.valid(options.version)) {
+      cancel2(
+        `The version specified (${pc5.bold(options.version)}) is not a valid semver version`
+      );
+      return 1;
+    }
+    nextVersion = options.version;
+    log3.info(`Using specified version: ${pc5.green(nextVersion)}`);
+  }
+  if (!nextVersion) {
+    const selectOptions = getVersionOptions(currentVersion);
+    const bumpSelection = await select({
+      message: "What package version bump is this release?",
+      options: selectOptions
+    });
+    if (isCancel2(bumpSelection)) {
+      cancel2("Release cancelled");
+      return 1;
+    }
+    nextVersion = bumpSelection;
+  }
+  const checkResult = await run2({
+    skipHeader: true,
+    quiet: true,
+    projectName: details.pkg.name,
+    version: nextVersion
+  });
+  if (checkResult !== 0) {
+    outro2(pc5.red("Release checks failed."));
+    return checkResult;
+  }
+  try {
+    await $2`npm version ${nextVersion}`;
+  } catch (err) {
+    outro2(
+      pc5.red(
+        `Failed to set version: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    return 1;
+  }
+  const pushSpinner = spin("Pushing release & tag to remote...");
+  try {
+    await $2`git push origin HEAD --follow-tags`.quiet();
+    pushSpinner.stop("Pushed to remote");
+  } catch (err) {
+    pushSpinner.cancel("Push failed");
+    outro2(
+      pc5.red(
+        `Failed to push to remote: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    await rollback(nextVersion);
+    return 1;
+  }
+  const deployResult = await run({ skipHeader: true });
+  if (deployResult !== 0) {
+    outro2(
+      pc5.red(
+        "Deployment failed. You can retry manually with `npm run deploy`."
+      )
+    );
+    return deployResult;
+  }
+  return 0;
+}
+var init_release = __esm({
+  "src/commands/release/index.ts"() {
+    "use strict";
+    init_terminal();
+    init_util();
+    init_semver();
+    init_release_check();
+    init_deploy();
+    init_git();
+  }
+});
+
+// src/lib/initHelpers.ts
+import fs2 from "node:fs/promises";
+import path5 from "node:path";
+import { stripTypeScriptTypes } from "node:module";
+import { $ as $3 } from "zx";
+async function copyContents(src, dest) {
+  await fs2.mkdir(dest, { recursive: true });
+  const entries = await fs2.readdir(src, { withFileTypes: true });
+  await Promise.all(
+    entries.map(async (entry) => {
+      const srcPath = path5.join(src, entry.name);
+      const destPath = path5.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        await copyContents(srcPath, destPath);
+      } else {
+        await fs2.copyFile(srcPath, destPath);
+      }
+    })
+  );
+}
+async function editPackageJson(dir, callback) {
+  const pkgPath2 = path5.join(dir, "package.json");
+  const pkg2 = await loadJson(pkgPath2) || {};
+  const result = await callback(pkg2);
+  const finalPkg = result || pkg2;
+  await fs2.writeFile(pkgPath2, JSON.stringify(finalPkg, null, 2) + "\n");
+}
+async function findFiles(dir, pattern) {
+  const { glob: glob2 } = await import("zx");
+  return await glob2(pattern, { cwd: dir, absolute: true });
+}
+async function replaceInFile(baseDir, relPath, replacements) {
+  const filePath = path5.join(baseDir, relPath);
+  let content = await fs2.readFile(filePath, "utf-8");
+  Object.entries(replacements).forEach(([search, replace]) => {
+    content = content.replaceAll(search, replace);
+  });
+  await fs2.writeFile(filePath, content);
+}
+async function replaceInFiles(baseDir, relPaths, replacements) {
+  await Promise.all(
+    relPaths.map((relPath) => replaceInFile(baseDir, relPath, replacements))
+  );
+}
+async function getGitUser() {
+  try {
+    const name = (await $3`git config user.name`.quiet()).stdout.trim();
+    const email = (await $3`git config user.email`.quiet()).stdout.trim();
+    if (!name || !email) return null;
+    return { name, email };
+  } catch {
+    return null;
+  }
+}
+async function installAunty(baseDir) {
+  const localDev = isLocalDevelopment();
+  let auntyDepValue = "";
+  const auntyRoot = path5.resolve(import.meta.dirname, "../../");
+  if (localDev) {
+    auntyDepValue = `file:${auntyRoot}`;
+  } else {
+    const pkg2 = await loadJson(
+      path5.join(auntyRoot, "package.json")
+    );
+    auntyDepValue = pkg2 ? `^${pkg2.version}` : "latest";
+  }
+  await editPackageJson(baseDir, (pkg2) => {
+    if (!pkg2.devDependencies) {
+      pkg2.devDependencies = {};
+    }
+    pkg2.devDependencies["@abcnews/aunty"] = auntyDepValue;
+  });
+}
+async function renameGitignore(baseDir) {
+  const { log: log8 } = await import("@clack/prompts");
+  const gitignoreFromPath = path5.resolve(baseDir, "_gitignore");
+  const gitignoreToPath = path5.resolve(baseDir, ".gitignore");
+  try {
+    await fs2.access(gitignoreFromPath);
+  } catch {
+    log8.error(
+      "Base template must include a _gitignore file (npm strips .gitignore)"
+    );
+    throw new Error("Missing _gitignore file");
+  }
+  await fs2.rename(gitignoreFromPath, gitignoreToPath);
+}
+function rewriteImports(content) {
+  return content.replace(/(from\s+['"])(.*?)\.ts(['"])/g, "$1$2.js$3").replace(/(import\s+['"])(.*?)\.ts(['"])/g, "$1$2.js$3");
+}
+async function stripTypesFromFile(tsFile) {
+  const jsFile = tsFile.replace(/\.ts$/, ".js");
+  const content = await fs2.readFile(tsFile, "utf-8");
+  const stripped = stripTypeScriptTypes(content);
+  const rewritten = rewriteImports(stripped);
+  await fs2.writeFile(jsFile, rewritten);
+  await fs2.unlink(tsFile);
+}
+var init_initHelpers = __esm({
+  "src/lib/initHelpers.ts"() {
+    "use strict";
+    init_util();
+  }
+});
+
+// templates/svelte/base/init.ts
+import path6 from "node:path";
+async function init({ projectName, baseDir }) {
+  const contentsDir = path6.resolve(import.meta.dirname, "contents");
+  await copyContents(contentsDir, baseDir);
+  await replaceInFiles(
+    baseDir,
+    ["index.html", "src/index.ts", "README.md"],
+    {
+      __PROJECT_NAME__: projectName,
+      __PROJECT_NAME_ACTO__: projectName.replace(/-/g, ""),
+      __PROJECT_TYPE__: "Svelte"
+    }
+  );
+  await renameGitignore(baseDir);
+  const gitUser = await getGitUser();
+  await editPackageJson(baseDir, (pkg2) => {
+    Object.assign(pkg2, {
+      name: projectName,
+      license: "MIT",
+      contributors: gitUser ? [gitUser] : [],
+      aunty: { type: "svelte" }
+    });
+  });
+  await installAunty(baseDir);
+}
+var init_init = __esm({
+  "templates/svelte/base/init.ts"() {
+    "use strict";
+    init_initHelpers();
+  }
+});
+
+// templates/svelte/patch-odyssey/init.ts
+async function init2({ baseDir }) {
+  await replaceInFile(baseDir, "src/index.ts", {
+    whenDOMReady: "whenOdysseyLoaded"
+  });
+}
+var init_init2 = __esm({
+  "templates/svelte/patch-odyssey/init.ts"() {
+    "use strict";
+    init_initHelpers();
+  }
+});
+
+// templates/svelte/patch-scrollyteller/init.ts
+import path7 from "node:path";
+async function init3({ projectName, baseDir }) {
+  const contentsDir = path7.resolve(import.meta.dirname, "contents");
+  await copyContents(contentsDir, baseDir);
+  await editPackageJson(baseDir, (pkg2) => {
+    pkg2.dependencies = pkg2.dependencies || {};
+    pkg2.dependencies["@abcnews/svelte-scrollyteller"] = "^3.0.0";
+  });
+  await replaceInFiles(baseDir, ["index.html", "src/index.ts"], {
+    __PROJECT_NAME__: projectName,
+    __PROJECT_NAME_ACTO__: projectName.replace(/-/g, "")
+  });
+}
+var init_init3 = __esm({
+  "templates/svelte/patch-scrollyteller/init.ts"() {
+    "use strict";
+    init_initHelpers();
+  }
+});
+
+// templates/svelte/patch-builder/init.ts
+var init_exports = {};
+__export(init_exports, {
+  init: () => init4
+});
+import path8 from "node:path";
+import fs3 from "node:fs/promises";
+async function init4({ projectName, baseDir }) {
+  const contentsDir = path8.resolve(import.meta.dirname, "contents");
+  await copyContents(contentsDir, baseDir);
+  await replaceInFile(baseDir, "builder/index.html", {
+    __PROJECT_NAME__: projectName
+  });
+  const entryFile = "src/index.ts";
+  const entryPath = path8.join(baseDir, entryFile);
+  const entryContent = await fs3.readFile(entryPath, "utf-8");
+  const searchPattern = `// __ADDITIONAL_MOUNTS__`;
+  const builderMountCode = `const [builderMountEl] = selectMounts('builder');
+
+if (builderMountEl) {
+  const appProps = getMountValue(builderMountEl);
+  const builderModule = await import('./components/Builder/Builder.svelte');
+  mount(builderModule.default, {
+    target: builderMountEl
+  });
+}
+
+// __ADDITIONAL_MOUNTS__`;
+  if (entryContent.includes(searchPattern)) {
+    await replaceInFile(baseDir, entryFile, {
+      [searchPattern]: builderMountCode
+    });
+  }
+}
+var init_init4 = __esm({
+  "templates/svelte/patch-builder/init.ts"() {
+    "use strict";
+    init_initHelpers();
+  }
+});
+
+// templates/svelte/patch-js/init.ts
+var init_exports2 = {};
+__export(init_exports2, {
+  init: () => init5
+});
+import fs4 from "node:fs/promises";
+import { $ as $4 } from "zx";
+import { stripTypeScriptTypes as stripTypeScriptTypes2 } from "node:module";
+async function processSvelteFile(file) {
+  let content = await fs4.readFile(file, "utf-8");
+  const scriptRegex = /<script lang="ts">([\s\S]*?)<\/script>/g;
+  const matches = Array.from(content.matchAll(scriptRegex));
+  if (matches.length === 0) return;
+  for (const match of matches) {
+    const stripped = stripTypeScriptTypes2(match[1]);
+    const rewritten = rewriteImports(stripped);
+    content = content.replace(
+      match[0],
+      `<script>
+${rewritten.trim()}
+</script>`
+    );
+  }
+  await fs4.writeFile(file, content);
+}
+async function init5({ baseDir }, hasBuilder) {
+  const s = spin("Converting project to JavaScript");
+  s.message("Converting .ts to .js");
+  const tsFiles = await findFiles(baseDir, "**/*.ts");
+  await Promise.all(tsFiles.map(stripTypesFromFile));
+  const svelteFiles = await findFiles(baseDir, "**/*.svelte");
+  await Promise.all(svelteFiles.map(processSvelteFile));
+  const htmlFiles = ["index.html"];
+  if (hasBuilder) {
+    htmlFiles.push("builder/index.html");
+  }
+  await replaceInFiles(baseDir, htmlFiles, { ".ts": ".js" });
+  s.message("Updating config");
+  s.message("Installing dependencies");
+  await $4({ cwd: baseDir })`npm install`.quiet();
+  s.message("Formatting project");
+  await $4({ cwd: baseDir })`npm run format`.quiet();
+  s.stop("Project converted to JavaScript");
+}
+var init_init5 = __esm({
+  "templates/svelte/patch-js/init.ts"() {
+    "use strict";
+    init_initHelpers();
+    init_terminal();
+  }
+});
+
+// templates/svelte/index.ts
+import { multiselect, cancel as cancel3, isCancel as isCancel3 } from "@clack/prompts";
+async function run4(options) {
+  const features = await multiselect({
+    message: "Select features to enable:",
+    options: [
+      { value: "odyssey", label: "Odyssey" },
+      { value: "scrollyteller", label: "Scrollyteller" },
+      { value: "builder", label: "Builder" },
+      { value: "typescript", label: "TypeScript" }
+    ],
+    initialValues: ["typescript"],
+    required: false
+  });
+  if (isCancel3(features)) {
+    cancel3("Operation cancelled.");
+    return 1;
+  }
+  const useTypescript = features.includes("typescript");
+  const useBuilder = features.includes("builder");
+  const useScrollyteller = features.includes("scrollyteller");
+  const useOdyssey = features.includes("odyssey");
+  await init(options);
+  if (useScrollyteller) {
+    await init3(options);
+  } else if (useOdyssey) {
+    await init2(options);
+  }
+  if (useBuilder) {
+    const { init: builderInit } = await Promise.resolve().then(() => (init_init4(), init_exports));
+    await builderInit(options);
+  }
+  if (!useTypescript) {
+    const { init: jsInit } = await Promise.resolve().then(() => (init_init5(), init_exports2));
+    await jsInit(options, useBuilder);
+  }
+  return 0;
+}
+var init_svelte = __esm({
+  "templates/svelte/index.ts"() {
+    "use strict";
+    init_init();
+    init_init2();
+    init_init3();
+  }
+});
+
+// templates/vanilla/base/init.ts
+import path9 from "node:path";
+async function init6({ projectName, baseDir }) {
+  const contentsDir = path9.resolve(import.meta.dirname, "contents");
+  await copyContents(contentsDir, baseDir);
+  await replaceInFiles(baseDir, ["index.html", "src/index.ts"], {
+    __PROJECT_NAME__: projectName,
+    __PROJECT_NAME_ACTO__: projectName.replace(/-/g, ""),
+    __PROJECT_TYPE__: "Svelte"
+  });
+  await renameGitignore(baseDir);
+  const gitUser = await getGitUser();
+  await editPackageJson(baseDir, (pkg2) => {
+    Object.assign(pkg2, {
+      name: projectName,
+      license: "MIT",
+      contributors: gitUser ? [gitUser] : [],
+      aunty: { type: "svelte" }
+    });
+  });
+  await installAunty(baseDir);
+}
+var init_init6 = __esm({
+  "templates/vanilla/base/init.ts"() {
+    "use strict";
+    init_initHelpers();
+  }
+});
+
+// templates/vanilla/patch-js/init.ts
+var init_exports3 = {};
+__export(init_exports3, {
+  init: () => init7
+});
+import { $ as $5 } from "zx";
+async function init7({ baseDir }) {
+  const s = spin("Converting project to JavaScript");
+  s.message("Converting .ts to .js");
+  const tsFiles = await findFiles(baseDir, "**/*.ts");
+  await Promise.all(tsFiles.map(stripTypesFromFile));
+  await replaceInFiles(baseDir, ["index.html"], { ".ts": ".js" });
+  s.message("Installing dependencies");
+  await $5({ cwd: baseDir })`npm install`.quiet();
+  s.message("Formatting project");
+  await $5({ cwd: baseDir })`npm run format`.quiet();
+  s.stop("Project converted to JavaScript");
+}
+var init_init7 = __esm({
+  "templates/vanilla/patch-js/init.ts"() {
+    "use strict";
+    init_initHelpers();
+    init_terminal();
+  }
+});
+
+// templates/vanilla/index.ts
+import { select as select2, confirm as confirm2, cancel as cancel4, isCancel as isCancel4 } from "@clack/prompts";
+async function run5(options) {
+  const projectType = await select2({
+    message: "What kind of project do you want?",
+    options: [{ value: "base", label: "Basic iframe/CoreMedia" }]
+  });
+  if (isCancel4(projectType)) {
+    cancel4("Operation cancelled.");
+    return 1;
+  }
+  const useTypescript = await confirm2({
+    message: "Do you want to use TypeScript?",
+    initialValue: true
+  });
+  if (isCancel4(useTypescript)) {
+    cancel4("Operation cancelled.");
+    return 1;
+  }
+  await init6(options);
+  if (!useTypescript) {
+    const { init: jsInit } = await Promise.resolve().then(() => (init_init7(), init_exports3));
+    await jsInit(options);
+  }
+  return 0;
+}
+var init_vanilla = __esm({
+  "templates/vanilla/index.ts"() {
+    "use strict";
+    init_init6();
+  }
+});
+
+// templates/index.ts
+var index, templates_default;
+var init_templates = __esm({
+  "templates/index.ts"() {
+    "use strict";
+    init_svelte();
+    init_vanilla();
+    index = {
+      projects: [
+        { name: "Svelte", run: run4 },
+        { name: "Plain JS", run: run5 }
+      ]
+    };
+    templates_default = index;
+  }
+});
+
+// src/commands/create/index.ts
+import {
+  intro as intro4,
+  outro as outro3,
+  text,
+  select as select3,
+  confirm as confirm3,
+  log as log4,
+  cancel as cancel5,
+  isCancel as isCancel5
+} from "@clack/prompts";
+import path10 from "node:path";
+import fs5 from "node:fs/promises";
+import pc6 from "picocolors";
+import { $ as $6 } from "zx";
+async function run6(destDirArg) {
+  intro4(getHeader(pc6.dim("aunty"), "create", { colour: "green" }));
+  const projectName = destDirArg || await text({
+    message: "What is your project named?",
+    placeholder: destDirArg || "my-new-project",
+    validate: (value) => {
+      if (!value || value.length === 0) {
+        return "Project name is required";
+      }
+      if (!value.match(/^[a-z0-9-]+$/)) {
+        return "Project name should be lowercase-alphanumeric-with-hypens";
+      }
+    }
+  });
+  if (isCancel5(projectName)) {
+    cancel5("Operation cancelled.");
+    return 0;
+  }
+  const finalProjectName = projectName || destDirArg || "my-new-project";
+  const projectDest = path10.resolve(process.cwd(), finalProjectName);
+  const ftpSpinner = spin("Checking project name availability...");
+  const isAvailable = await isProjectNameAndVersionAvailable(finalProjectName);
+  ftpSpinner.stop("Project name checked");
+  if (isAvailable === "error") {
+    const shouldContinue = await confirm3({
+      message: pc6.red(
+        "Could not connect to FTP to check name availability. Continue anyway?"
+      ),
+      initialValue: true
+    });
+    if (!shouldContinue || isCancel5(shouldContinue)) {
+      cancel5("Create cancelled.");
+      return 0;
+    }
+  }
+  if (isAvailable === "exists") {
+    const shouldContinue = await confirm3({
+      message: pc6.yellow(
+        `Project name "${finalProjectName}" already exists on FTP. Continue?`
+      ),
+      initialValue: false
+    });
+    if (!shouldContinue || isCancel5(shouldContinue)) {
+      cancel5("Create cancelled.");
+      return 0;
+    }
+  }
+  const projectType = await select3({
+    message: "Select a project type:",
+    options: templates_default.projects.map((p) => ({ value: p, label: p.name }))
+  });
+  if (isCancel5(projectType)) {
+    cancel5("Operation cancelled.");
+    return 0;
+  }
+  const selectedProject = projectType;
+  if (await fs5.access(projectDest).then(() => true).catch(() => false)) {
+    cancel5(`Directory ${pc6.cyan(projectDest)} already exists.`);
+    return 1;
+  }
+  try {
+    const exitCode = await selectedProject.run({
+      projectName: finalProjectName,
+      baseDir: projectDest
+    });
+    if (exitCode !== 0) {
+      return 0;
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    cancel5(`Failed to create project: ${message}`);
+    if (err instanceof Error && err.stack) {
+      console.error(err.stack);
+    }
+    return 1;
+  }
+  const installSpinner = spin("Installing dependencies...");
+  try {
+    await $6({ cwd: projectDest })`npm install`.quiet();
+    installSpinner.stop("Dependencies installed");
+  } catch {
+    installSpinner.cancel(
+      "Failed to install dependencies. You may need to run 'npm install' manually."
+    );
+  }
+  try {
+    await $6({ cwd: projectDest })`git init`.quiet();
+  } catch {
+  }
+  log4.step("Next steps:");
+  log4.message(
+    `
+${pc6.bold(1)}. cd ${finalProjectName}
+${pc6.bold(2)}. npm run dev
+`.trim()
+  );
+  outro3("Happy coding.");
+  return 0;
+}
+var init_create = __esm({
+  "src/commands/create/index.ts"() {
+    "use strict";
+    init_terminal();
+    init_ftp();
+    init_templates();
+  }
+});
+
+// src/commands/build/index.ts
+import { intro as intro5, outro as outro4, log as log5 } from "@clack/prompts";
+import pc7 from "picocolors";
+async function run7() {
+  intro5(getHeader(pc7.dim("aunty"), "build", { colour: "blue" }));
+  outro4("Building project for production...");
+  try {
+    await runBuild({ stdio: "inherit" });
+    return 0;
+  } catch (err) {
+    if (err.exitCode !== void 0) {
+      return err.exitCode;
+    }
+    log5.error(err.message || `Failed to start npm command: ${err.message}`);
+    return 1;
+  }
+}
+var init_build = __esm({
+  "src/commands/build/index.ts"() {
+    "use strict";
+    init_terminal();
+    init_util();
+  }
+});
+
+// src/commands/serve/index.ts
+import { intro as intro6, outro as outro5, log as log6 } from "@clack/prompts";
+import pc8 from "picocolors";
+import { $ as $7 } from "zx";
+async function run8() {
+  intro6(getHeader(pc8.dim("aunty"), "serve", { colour: "cyan" }));
+  outro5("Starting development server...");
+  const details = await findProjectDetails(process.cwd());
+  if (!details) return 1;
+  const { pkg: pkg2 } = details;
+  const hasDevScript = !!pkg2.scripts?.dev;
+  if (!hasDevScript) {
+    log6.error(
+      `Could not find a ${pc8.cyan("dev")} script in package.json.`
+    );
+    return 1;
+  }
+  try {
+    const isVite = pkg2.scripts?.dev?.includes("vite");
+    if (isVite) {
+      await $7({ stdio: "inherit" })`npm run dev -- --clearScreen false`;
+    } else {
+      await $7({ stdio: "inherit" })`npm run dev`;
+    }
+    return 0;
+  } catch (err) {
+    if (err.exitCode !== void 0) {
+      return err.exitCode;
+    }
+    log6.error(`Failed to start npm command: ${err.message}`);
+    return 1;
+  }
+}
+var init_serve = __esm({
+  "src/commands/serve/index.ts"() {
+    "use strict";
+    init_terminal();
+    init_util();
+  }
+});
+
+// src/commands/migrate/index.ts
+import { intro as intro7, outro as outro6, confirm as confirm4, log as log7, cancel as cancel6, isCancel as isCancel6 } from "@clack/prompts";
+import path11 from "node:path";
+import fs6 from "node:fs/promises";
+import pc9 from "picocolors";
+import { $ as $8, glob } from "zx";
+async function migrateHtmlFile(srcPath, destPath, entryFile) {
+  let content = await fs6.readFile(srcPath, "utf-8");
+  content = content.replace(
+    /<script\s+src=["'](?:index\.js|index_modern\.js)["']\s*><\/script>/gi,
+    ""
+  );
+  content = content.replace(/<!--[\s\S]*?-->/g, "");
+  content = content.replace(/<script([\s\S]*?)>([\s\S]*?)<\/script>/gi, (match, attributes, innerContent) => {
+    const hasOdysseyApi = innerContent.includes("odyssey:api");
+    const isClassicScript = !attributes.trim() || attributes.includes('type="text/javascript"') || attributes.includes("type='text/javascript'");
+    if (hasOdysseyApi && isClassicScript) {
+      return `<script type="module">${innerContent}</script>`;
+    }
+    return match;
+  });
+  const scriptTag = `<script type="module" src="/${entryFile}"></script>`;
+  if (content.includes("</head>")) {
+    content = content.replace("</head>", `  ${scriptTag}
+  </head>`);
+  } else {
+    content = scriptTag + "\n" + content;
+  }
+  await fs6.mkdir(path11.dirname(destPath), { recursive: true });
+  await fs6.writeFile(destPath, content);
+  await fs6.unlink(srcPath);
+}
+async function run9(options = {}) {
+  intro7(getHeader(pc9.dim("aunty"), "migrate", { colour: "rainbow" }));
+  const details = await findProjectDetails(process.cwd());
+  if (!details) {
+    cancel6(
+      "Could not find package.json. Please run this command inside an aunty project."
+    );
+    return 1;
+  }
+  const baseDir = details.root;
+  const configPath = path11.join(baseDir, "aunty.config.js");
+  const hasConfig = await fs6.access(configPath).then(() => true).catch(() => false);
+  if (hasConfig) {
+    log7.error(
+      `Found legacy ${pc9.cyan("aunty.config.js")} at the root of the project. We cannot migrate this project automatically. Please delete or rename the file before continuing, and configure Vite manually after migration.`
+    );
+    return 1;
+  }
+  if (!options.skipGit) {
+    const gitAccessible = await isAccessible();
+    const insideRepo = gitAccessible ? await isInsideRepo() : false;
+    if (!gitAccessible) {
+      log7.error(
+        "Git is not accessible (please ensure git is installed and Xcode/licenses are accepted)."
+      );
+      return 1;
+    }
+    if (!insideRepo) {
+      log7.error("The current directory is not a git repository.");
+      return 1;
+    }
+    if (!await isClean()) {
+      log7.error(
+        "You have uncommitted changes. Please commit or stash them before migrating."
+      );
+      return 1;
+    }
+    if (await hasRemote()) {
+      if (await isBehindRemote()) {
+        log7.error(
+          "Your local branch is behind the remote. Please pull the latest changes before migrating."
+        );
+        return 1;
+      }
+    }
+  }
+  const publicHtmlPath = path11.join(baseDir, "public/index.html");
+  try {
+    await fs6.access(publicHtmlPath);
+  } catch {
+    log7.error(
+      `Could not find public/index.html. This project does not seem to match the expected legacy structure.`
+    );
+    return 1;
+  }
+  const hasTS = await fs6.access(path11.join(baseDir, "src/index.ts")).then(() => true).catch(() => false);
+  const hasJS = await fs6.access(path11.join(baseDir, "src/index.js")).then(() => true).catch(() => false);
+  if (!hasTS && !hasJS) {
+    log7.error("Could not find src/index.ts or src/index.js entry point.");
+    return 1;
+  }
+  const entryFile = hasTS ? "src/index.ts" : "src/index.js";
+  log7.message("Attempt to migrate an Aunty Webpack project to Aunty Vite.");
+  log7.message(
+    "This is a fairly naive and destructive process, and may not work for your specific configuration."
+  );
+  log7.message(
+    "Please make take a backup or ensure Git is pushed before proceeding."
+  );
+  if (!options.yes) {
+    const shouldContinue = await confirm4({
+      message: "Are you sure you want to migrate this project to Vite?",
+      initialValue: true
+    });
+    if (!shouldContinue || isCancel6(shouldContinue)) {
+      cancel6("Migration cancelled.");
+      return 0;
+    }
+  }
+  const migrationSpinner = spin("Migrating configuration files...");
+  try {
+    const templateDir = path11.resolve(
+      import.meta.dirname,
+      "../../../templates/svelte/base/contents"
+    );
+    const filesToCopy = [
+      "vite.config.ts",
+      "svelte.config.js",
+      "tsconfig.json",
+      "tsconfig.app.json",
+      "tsconfig.node.json"
+    ];
+    for (const file of filesToCopy) {
+      const srcPath = path11.join(templateDir, file);
+      const destPath = path11.join(baseDir, file);
+      await fs6.copyFile(srcPath, destPath);
+    }
+    const templateGitignorePath = path11.join(templateDir, "_gitignore");
+    const targetGitignorePath = path11.join(baseDir, ".gitignore");
+    let existingGitignore = "";
+    try {
+      existingGitignore = await fs6.readFile(targetGitignorePath, "utf-8");
+    } catch {
+    }
+    const templateGitignore = await fs6.readFile(templateGitignorePath, "utf-8");
+    const uniqueRules = Array.from(
+      new Set(
+        [
+          ...existingGitignore.split(/\r?\n/),
+          ...templateGitignore.split(/\r?\n/)
+        ].map((line) => line.trim()).filter((line) => line && !line.startsWith("#"))
+      )
+    );
+    await fs6.writeFile(targetGitignorePath, uniqueRules.join("\n") + "\n");
+    const destHtmlPath = path11.join(baseDir, "index.html");
+    await migrateHtmlFile(publicHtmlPath, destHtmlPath, entryFile);
+    const publicBuilderHtmlPath = path11.join(baseDir, "public/builder/index.html");
+    const hasLegacyBuilder = await fs6.access(publicBuilderHtmlPath).then(() => true).catch(() => false);
+    if (hasLegacyBuilder) {
+      const destBuilderHtmlPath = path11.join(baseDir, "builder/index.html");
+      await migrateHtmlFile(publicBuilderHtmlPath, destBuilderHtmlPath, entryFile);
+      try {
+        await fs6.rmdir(path11.join(baseDir, "public/builder"));
+      } catch {
+      }
+    }
+    migrationSpinner.stop(
+      "Configuration files updated and index.html migrated successfully" + (hasLegacyBuilder ? " (including builder)" : "")
+    );
+  } catch (err) {
+    migrationSpinner.cancel("Failed during file migration step");
+    log7.error(err.message || String(err));
+    return 1;
+  }
+  const pkgSpinner = spin("Updating package.json dependencies and scripts...");
+  try {
+    const templateDir = path11.resolve(
+      import.meta.dirname,
+      "../../../templates/svelte/base/contents"
+    );
+    const pkgPath2 = path11.join(baseDir, "package.json");
+    const pkg2 = await loadJson(pkgPath2);
+    const templatePkg = await loadJson(
+      path11.join(templateDir, "package.json")
+    );
+    pkg2.type = "module";
+    if (!pkg2.scripts) pkg2.scripts = {};
+    pkg2.scripts.dev = "vite serve";
+    pkg2.scripts.build = "vite build";
+    pkg2.scripts.check = "svelte-check --tsconfig ./tsconfig.app.json && tsc -p tsconfig.node.json";
+    pkg2.scripts.format = "prettier --write .";
+    if (pkg2.scripts.start === "aunty serve") {
+      delete pkg2.scripts.start;
+    }
+    if (!pkg2.dependencies) pkg2.dependencies = {};
+    if (!pkg2.devDependencies) pkg2.devDependencies = {};
+    const oldDeps = { ...pkg2.dependencies || {}, ...pkg2.devDependencies || {} };
+    const hasSassDep = "sass" in oldDeps || "node-sass" in oldDeps;
+    const scssFiles = await glob("src/**/*.s[ac]ss", { cwd: baseDir });
+    const hasSass = hasSassDep || scssFiles.length > 0;
+    Object.assign(pkg2.dependencies, templatePkg.dependencies || {});
+    Object.assign(pkg2.devDependencies, templatePkg.devDependencies || {});
+    if (hasSass) {
+      pkg2.devDependencies["sass-embedded"] = "^1.83.0";
+    }
+    await fs6.writeFile(pkgPath2, JSON.stringify(pkg2, null, 2) + "\n");
+    await installAunty(baseDir);
+    pkgSpinner.stop("package.json updated");
+  } catch (err) {
+    pkgSpinner.cancel("Failed to update package.json");
+    log7.error(err.message || String(err));
+    return 1;
+  }
+  const installSpinner = spin("Installing dependencies via npm...");
+  try {
+    await $8({ cwd: baseDir })`npm install`.quiet();
+    installSpinner.stop("Dependencies installed");
+  } catch (err) {
+    installSpinner.cancel("Failed to install dependencies.");
+    log7.error(`npm install failed: ${err.message || String(err)}`);
+    return 1;
+  }
+  outro6(
+    "Migration completed successfully! You can now run 'npm run dev' to start development."
+  );
+  return 0;
+}
+var init_migrate = __esm({
+  "src/commands/migrate/index.ts"() {
+    "use strict";
+    init_terminal();
+    init_util();
+    init_git();
+    init_initHelpers();
+  }
+});
+
+// src/lib/colours.json
+var colours_default;
+var init_colours = __esm({
+  "src/lib/colours.json"() {
+    colours_default = {
+      commands: {
+        deploy: "red",
+        create: "green",
+        new: "green",
+        "release-check": "magenta",
+        release: "yellow",
+        serve: "cyan",
+        build: "blue",
+        migrate: "rainbow"
+      }
+    };
+  }
+});
+
+// src/bin/commander.ts
+var commander_exports = {};
+import path12 from "node:path";
+import { Command, Help } from "commander";
+import pc10 from "picocolors";
+var colours, pcColors, pkgPath, pkg, version, program;
+var init_commander = __esm({
+  async "src/bin/commander.ts"() {
+    "use strict";
+    init_deploy();
+    init_release_check();
+    init_release();
+    init_create();
+    init_build();
+    init_serve();
+    init_migrate();
+    init_terminal();
+    init_util();
+    init_colours();
+    colours = colours_default;
+    pcColors = pc10;
+    pkgPath = path12.join(import.meta.dirname, "../../package.json");
+    pkg = await loadJson(pkgPath);
+    version = pkg?.version || "0.0.0";
+    program = new Command();
+    program.name("aunty").description(
+      getHeader(
+        `${pkg.name}${pc10.dim("@" + pkg.version)}`,
+        `${pc10.dim(pkg.description.slice(0, 73))}`,
+        { prepend: "" }
+      ) + "\n" + pc10.dim("\u2500".repeat(80))
+    ).version(version);
+    program.configureHelp({
+      subcommandTerm: (cmd) => {
+        const name = cmd.name();
+        const colourName = colours.commands[name];
+        const colourFn = colourName && typeof pcColors[colourName] === "function" ? pcColors[colourName] : (str) => str;
+        const term = new Help().subcommandTerm(cmd);
+        return term.replace(name, colourFn(name));
+      },
+      formatHelp: (cmd, helper) => {
+        const baseHelp = new Help().formatHelp(cmd, helper);
+        if (cmd.parent) {
+          const name = cmd.name();
+          const colourName = colours.commands[name] || "rainbow";
+          const logoHeader = getHeader("aunty", name, {
+            prepend: "",
+            colour: colourName
+          });
+          return `${logoHeader}
+
+${baseHelp}`;
+        }
+        return baseHelp;
+      }
+    });
+    program.command("deploy").description(
+      "Deploy the project to FTP. This deploys the current dist/ folder to the specified remote folder, falling back to the current version number. Use this to retry a failed release."
+    ).argument(
+      "[destDir]",
+      "Override the target folder name (defaults to package.json version)"
+    ).option("-d, --dry-run", "Show what would happen without uploading", false).option("-f, --force", "Overwrite the remote directory if it exists", false).action(async (destDir, options) => {
+      process.exit(await run({ destDir, ...options }));
+    });
+    program.command("create").description("Create a new project from a template").argument("[destDir]", "Directory to create the project in").action(async (destDir) => {
+      process.exit(await run6(destDir));
+    });
+    program.command("new", { hidden: true }).description("Alias for create").argument("[destDir]", "Directory to create the project in").action(async (destDir) => {
+      process.exit(await run6(destDir));
+    });
+    program.command("release-check").description("Perform pre-release checks").action(async () => {
+      process.exit(await run2());
+    });
+    program.command("release").description("Version and release your project to FTP").option("--version <version>", "Override the release version directly").action(async (options) => {
+      process.exit(await run3(options));
+    });
+    program.command("serve").description("Start a local development server").action(async () => {
+      await run8();
+    });
+    program.command("build").description("Build the project for production").action(async () => {
+      process.exit(await run7());
+    });
+    program.command("migrate").description("Migrate a legacy project to use Vite and the latest version of aunty").option("-y, --yes", "Skip confirmation prompt", false).option("--skip-git", "Skip Git safety checks", false).action(async (options) => {
+      process.exit(await run9(options));
+    });
+    program.command("dev-colours", { hidden: true }).description("Test all available gradient colours").action(() => {
+      printDevColours();
+      process.exit(0);
+    });
+    try {
+      await program.parseAsync(process.argv);
+    } catch (err) {
+      if (err instanceof Error) {
+        console.error(`${pc10.dim(err.stack)}`);
+      } else {
+        console.error(`${pc10.red(pc10.bold("Error:"))} ${pc10.red(`\u2018${String(err)}\u2019`)}`);
+      }
+      console.error(
+        `${pc10.red(pc10.bold("\u25A0 Aunty has encountered an unhandled error."))}
+\u2514 This is likely a bug. Please report it at: ${pc10.cyan("https://github.com/abcnews/aunty/issues/new")}`
+      );
+      process.exit(1);
+    }
+  }
+});
+
+// src/bin/aunty.ts
+import { existsSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import path13 from "node:path";
+import { fileURLToPath } from "node:url";
+import { $ as $9 } from "zx";
+var filename = fileURLToPath(import.meta.url);
+async function run10() {
+  const localAuntyPath = path13.join(
+    process.cwd(),
+    "node_modules/@abcnews/aunty/dist/bin/aunty.js"
+  );
+  const isMigrate = process.argv.includes("migrate");
+  if (!isMigrate && existsSync(localAuntyPath) && await realpath(localAuntyPath) !== await realpath(filename)) {
+    const result = await $9({ stdio: "inherit", nothrow: true })`${process.execPath} ${localAuntyPath} ${process.argv.slice(2)}`;
+    process.exit(result.exitCode);
+  }
+  await init_commander().then(() => commander_exports);
+}
+run10().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});