@gluhar/cli 3.0.0 → 3.0.2

package/package.json

@@ -1,48 +1,48 @@
 {
-    "name": "@gluhar/cli",
-    "version": "3.0.0",
-    "description": "Gluhar cli commands and scripts",
-    "exports": {
-        ".": "./src/index.ts",
-        "./*": "./src/*/index.ts"
-    },
-    "main": "./src/index.js",
-    "bin": {
-        "gluhar": "./src/index.js"
-    },
-    "scripts": {
-        "clean": "rm -rf dist",
-        "copy:files": "copyfiles \"src/**/*.sh\" dist",
-        "build": "tsc && tsc-alias && npm run copy:files",
-        "prepack": "npm run build",
-        "dev": "npm run build && node ./dist/src/index.js"
-    },
-    "dependencies": {
-        "chalk": "^4.1.2",
-        "commander": "^12.1.0",
-        "fs-extra": "^11.2.0",
-        "glob": "^11.0.0",
-        "humps": "^2.0.1",
-        "inquirer": "^8.2.6",
-        "istextorbinary": "^9.5.0",
-        "npmlog": "^7.0.1",
-        "shelljs": "^0.8.5",
-        "ts-morph": "^25.0.0"
-    },
-    "devDependencies": {
-        "@nuxt/eslint-config": "^0.5.6",
-        "@nuxt/schema": "^3.13.1",
-        "@types/fs-extra": "^11.0.4",
-        "@types/humps": "^2.0.6",
-        "@types/inquirer": "^8.2.10",
-        "@types/istextorbinary": "^2.3.4",
-        "@types/node": "^20.16.5",
-        "@types/npmlog": "^7.0.0",
-        "@types/shelljs": "^0.8.15",
-        "eslint": "^9.10.0",
-        "tsc-alias": "^1.8.10",
-        "tsconfig-paths": "^4.2.0",
-        "typescript": "^5.5.4"
-    },
-    "gitHead": "2436c442afd73078fc82efdaee9553110b3b790e"
+  "name": "@gluhar/cli",
+  "version": "3.0.2",
+  "description": "Gluhar cli commands and scripts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./*": "./src/*/index.ts"
+  },
+  "main": "./src/index.js",
+  "bin": {
+    "gluhar": "./src/index.js"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "copy:files": "copyfiles \"src/**/*.sh\" dist",
+    "build": "tsc && tsc-alias && npm run copy:files",
+    "prepack": "npm run build",
+    "dev": "npm run build && node ./dist/src/index.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0",
+    "glob": "^11.0.0",
+    "humps": "^2.0.1",
+    "inquirer": "^8.2.6",
+    "istextorbinary": "^9.5.0",
+    "npmlog": "^7.0.1",
+    "shelljs": "^0.8.5",
+    "ts-morph": "^25.0.0"
+  },
+  "devDependencies": {
+    "@nuxt/eslint-config": "^0.5.6",
+    "@nuxt/schema": "^3.13.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/humps": "^2.0.6",
+    "@types/inquirer": "^8.2.10",
+    "@types/istextorbinary": "^2.3.4",
+    "@types/node": "^20.16.5",
+    "@types/npmlog": "^7.0.0",
+    "@types/shelljs": "^0.8.15",
+    "eslint": "^9.10.0",
+    "tsc-alias": "^1.8.10",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.5.4"
+  },
+  "gitHead": "37c79c38049ee2d91e649523539808c2fdbffd88"
 }

package/src/GlobalOptions.ts

@@ -0,0 +1,8 @@
+import type { LogLevel } from './utils';
+
+export interface GlobalOptions {
+  logLevel: LogLevel;
+  logPrefix?: string[];
+  ci: boolean;
+  cwd?: string;
+}

package/src/commands/blank/BlankOptions.ts

@@ -0,0 +1,3 @@
+export interface BlankOptions {
+  blank: boolean;
+}

package/src/commands/blank/blank.ts

@@ -0,0 +1,6 @@
+import { BlankOptions } from "./BlankOptions";
+import { log } from "./log";
+
+export const blank = (options: BlankOptions) => {
+  log.info("blank", options);
+};

package/src/commands/blank/index.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+import { blank } from "./blank";
+
+export default new Command()
+  .name("blank")
+  .description("Description of command.")
+  .option("-b, --blank", "A boolean option.")
+  .action(blank);

package/src/commands/blank/log.ts

@@ -0,0 +1,3 @@
+import { logger } from "src/utils";
+
+export const log = logger("blank");

package/src/commands/build/BuildOptions.ts

@@ -0,0 +1,3 @@
+export interface BuildOptions {
+  type: "module";
+}

package/src/commands/build/build.ts

@@ -0,0 +1,24 @@
+import { executeCmd } from "src/scripts/cmd";
+import { BuildOptions } from "./BuildOptions";
+import { log } from "./log";
+
+export const build = (options: BuildOptions) => {
+  const { type } = options;
+
+  // INFO Nuxt modules need a structure of [pkg.json, dist/] to function properly where as my release script needs all pkgs to be released from a dist folder
+  if (type === "module") {
+    log.info("Build nuxt module in dist");
+    executeCmd("nuxt-module-build build");
+
+    log.info("Copy contents of dist on level down");
+    executeCmd('copyfiles "dist/**/*" dist');
+
+    // log.info("Delete the copied files");
+    // executeCmd(
+    //   "find ./dist -mindepth 1 ! -path './dist/dist*' -exec rm -rf {} +"
+    // );
+
+    log.info("Copy pkg.json and mds to dist as well");
+    executeCmd("copyfiles package.json README.md CHANGELOG.md dist");
+  }
+};

package/src/commands/build/index.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+import { build } from "./build";
+
+export default new Command()
+  .name("build")
+  .description("Command for building various things.")
+  .option("-t, --type [type]", "What kind of thing to build.")
+  .action(build);

package/src/commands/build/log.ts

@@ -0,0 +1,3 @@
+import { logger } from "src/utils";
+
+export const log = logger("build");

package/src/commands/deinstall/DeinstallOptions.ts

@@ -0,0 +1,3 @@
+export interface DeinstallOptions {
+  packages?: boolean;
+}

package/src/commands/deinstall/deinstall.ts

@@ -0,0 +1,19 @@
+import { executeCmd } from "src/scripts/cmd";
+import { DeinstallOptions } from "./DeinstallOptions";
+import { log } from "./log";
+
+export const deinstall = (options: DeinstallOptions) => {
+  if (options.packages) {
+    // Remove node_modules in each folder inside /packages
+    log.info("Deleting node_modules from root and packages. (-p)");
+    executeCmd("rm -rf node_modules ./packages/**/node_modules");
+  } else {
+    // Remove node_modules recursively
+    log.info("Deleting node_modules.");
+    executeCmd("rm -rf node_modules");
+  }
+
+  // Remove package-lock.json
+  log.info("Deleting package-lock.");
+  executeCmd("rm package-lock.json");
+};

package/src/commands/deinstall/index.ts

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+import { deinstall } from "./deinstall";
+
+export default new Command()
+  .name("deinstall")
+  .description("Remove node_modules and package-lock.json.")
+  .option(
+    "-p, --packages",
+    "Deinstall dependencies in /packages (intended for module authors)."
+  )
+  .action(deinstall);

package/src/commands/deinstall/log.ts

@@ -0,0 +1,3 @@
+import { logger } from "src/utils";
+
+export const log = logger("deinstall");

package/src/commands/deploy/DeployOptions.ts

@@ -0,0 +1,6 @@
+export interface DeployOptions {
+  from?: string;
+  ios?: boolean;
+  android?: boolean;
+  ssr?: boolean;
+}

package/src/commands/deploy/deploy.ts

@@ -0,0 +1,39 @@
+import { git } from "src/scripts/git";
+import { DeployOptions } from "./DeployOptions";
+import { log } from "./log";
+import { deployIos } from "./deployIos";
+import { setSsr } from "./setSsr";
+import { confirmQuestion } from "src/utils";
+
+export const deploy = async (options: DeployOptions) => {
+  log.info("Deploying app...", options);
+
+  // Deploy app to iOS
+  if (options.ios) {
+    deployIos();
+    return;
+  }
+
+  // Handle ssr
+  if (options.ssr !== undefined) {
+    log.info(`Setting ssr to ${options.ssr} and committing to git`);
+    setSsr(options.ssr);
+    git.commit({ m: `chore: Set SSR to ${options.ssr}` });
+  }
+
+  // Default Deploy app to web
+  const fromBranch = options.from || "dev";
+  const { remote } = git.branch.exists("deploy");
+
+  git.branch.checkout("deploy", { newBranch: !remote });
+  log.info("Checked out to deploy branch");
+
+  git.merge(fromBranch, true);
+  log.info(`Merged with ${fromBranch}`);
+
+  git.push("deploy");
+  log.info("Pushed to deploy");
+
+  git.branch.checkout(fromBranch);
+  log.info(`Checked out back to ${fromBranch}`);
+};

package/src/commands/deploy/deployIos.ts

@@ -0,0 +1,48 @@
+import { executeCmd } from "src/scripts/cmd";
+import { log } from "./log";
+import { Project, SyntaxKind } from "ts-morph";
+import { setSsr } from "./setSsr";
+
+const project = new Project();
+
+export const deployIos = async (url?: string) => {
+  log.info("Deploying iOS app.");
+
+  // Remove server dev url from capacitor config
+  const capConfig = project.addSourceFileAtPathIfExists(
+    "./capacitor.config.ts"
+  );
+  if (!capConfig) return;
+
+  const capConfigObject = capConfig
+    ?.getVariableDeclaration("config")
+    ?.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+  if (!capConfigObject) return;
+
+  const server = capConfigObject.getProperty("server");
+
+  if (!url) {
+    server?.remove();
+  } else {
+    if (server) {
+      server.set({ initializer: `{ url: '${url}' }` });
+    } else {
+      capConfigObject.addPropertyAssignment({
+        name: "server",
+        initializer: `{ url: '${url}' }`,
+      });
+    }
+  }
+
+  capConfig.saveSync();
+
+  // Disable ssr from nuxt.config
+  setSsr(false);
+
+  // Generate static nuxt app
+  executeCmd("nuxi generate");
+
+  // Sync and open iOS app with Capacitor
+  executeCmd("cap sync ios");
+  executeCmd("cap open ios");
+};

package/src/commands/deploy/index.ts

@@ -0,0 +1,20 @@
+import { Command } from "commander";
+import { deploy } from "./deploy";
+
+export default new Command()
+  .name("deploy")
+  .description(
+    "Deploy a Nuxt app. Check out to deploy branch, merge with dev and check out back to dev."
+  )
+  .option(
+    "--from <branch>",
+    "From what branch to deploy. Default is 'dev' so this is used in the event we are deploying from a different branch.",
+    "dev"
+  )
+  .option("--ios", "Deploy app to iOS device using Capacitor.")
+  .option("--android", "Deploy app to Android device using Capacitor.")
+  .option(
+    "--ssr",
+    "Set SSR before deployment. Default is undefined for no change."
+  )
+  .action(deploy);

package/src/commands/deploy/log.ts

@@ -0,0 +1,3 @@
+import { logger } from "src/utils";
+
+export const log = logger("deploy");

package/src/commands/deploy/setSsr.ts

@@ -0,0 +1,25 @@
+import { Project, SyntaxKind } from "ts-morph";
+
+const project = new Project();
+
+export const setSsr = (ssr: boolean) => {
+  const nuxtConfig = project.addSourceFileAtPath("./nuxt.config.ts");
+  if (!nuxtConfig) return;
+
+  const nuxtConfigDefault = nuxtConfig?.getFirstDescendantByKind(
+    SyntaxKind.ObjectLiteralExpression
+  );
+  if (!nuxtConfigDefault) return;
+
+  const nuxtConfigSsr = nuxtConfigDefault.getProperty("ssr");
+  if (nuxtConfigSsr) {
+    nuxtConfigSsr.set({ initializer: `${ssr}` });
+  } else {
+    nuxtConfigDefault.addPropertyAssignment({
+      name: "ssr",
+      initializer: `${ssr}`,
+    });
+  }
+
+  nuxtConfig.saveSync();
+};

package/src/commands/dev/DevOptions.ts

@@ -0,0 +1,4 @@
+export interface DevOptions {
+  host?: boolean;
+  ios?: boolean;
+}

package/src/commands/dev/dev.ts

@@ -0,0 +1,15 @@
+import { executeCmd } from "src/scripts/cmd";
+import { DevOptions } from "./DevOptions";
+import { log } from "./log";
+import { devIos } from "./devIos";
+
+export const dev = async (options: DevOptions) => {
+  log.info("Running dev...", options);
+
+  if (options.ios) {
+    options.host = true;
+    await devIos(options);
+  }
+  // Run nuxt server
+  executeCmd("nuxt dev", options.host ? { host: "0.0.0.0" } : undefined);
+};

package/src/commands/dev/devIos.ts

@@ -0,0 +1,23 @@
+import { deployIos } from "../deploy/deployIos";
+import { DevOptions } from "./DevOptions";
+import os from "os";
+
+const getLocalIP = () => {
+  const interfaces = os.networkInterfaces();
+  for (const iface of Object.values(interfaces)) {
+    if (!iface) continue;
+
+    for (const config of iface) {
+      if (config.family === "IPv4" && !config.internal) {
+        return config.address;
+      }
+    }
+  }
+};
+
+export const devIos = async (options: DevOptions) => {
+  const ip = getLocalIP();
+  const url = `http://${ip}:3000`; // TODO dynamic ssl and port ?
+
+  await deployIos(url);
+};

package/src/commands/dev/index.ts

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import { dev } from "./dev";
+
+export default new Command()
+  .name("dev")
+  .description("Description of command.")
+  .option("-h, --host", "Run nuxt dev server exposed to the local network.")
+  .option(
+    "--ios",
+    "Run dev for ios. Runs nuxt dev host and deploys to ios device with server url."
+  )
+  .action(dev);

package/src/commands/dev/log.ts

@@ -0,0 +1,3 @@
+import { logger } from "src/utils";
+
+export const log = logger("dev");

package/src/commands/generate/GenerateOptions.ts

@@ -0,0 +1,9 @@
+export const generateTypes = ["project", "package", "command"] as const;
+export type GenerateType = (typeof generateTypes)[number];
+
+export interface GenerateOptions {
+  starter?: string;
+  noRepo?: boolean;
+  keepHistory?: boolean;
+  yes: boolean;
+}

package/src/commands/generate/generate.ts

@@ -0,0 +1,29 @@
+import {
+  GenerateOptions,
+  GenerateType,
+  generateTypes,
+} from "./GenerateOptions";
+import { log } from "./log";
+import { generateCommand } from "./generateCommand";
+import { generateProject } from "./generateProject";
+
+const cwd = process.cwd();
+
+export const generate = async (
+  type: GenerateType,
+  name: string,
+  options: GenerateOptions
+) => {
+  if (!generateTypes.includes(type)) {
+    log.error("Invalid type. Nothing to generate.");
+    return;
+  }
+
+  log.info("Generating", type, name);
+
+  if (type === "command") {
+    await generateCommand(name, cwd);
+  } else if (type === "project") {
+    await generateProject(name, cwd, options);
+  }
+};

package/src/commands/generate/generateCommand.ts

@@ -0,0 +1,46 @@
+import { filesystem } from "src/scripts/filesystem";
+import { log } from "./log";
+import { join } from "path";
+import { capitalize } from "src/utils/common";
+
+export const generateCommand = async (name: string, cwd: string) => {
+  if (!cwd.includes("packages/cli")) {
+    log.error(
+      "You must be in the packages/cli directory to generate a command."
+    );
+    return;
+  }
+
+  filesystem.copyDir(
+    join(cwd, "src/commands/blank"),
+    join(cwd, `src/commands/${name}`),
+    (file) => {
+      const content = file.content
+        .replaceAll("blank", name)
+        .replaceAll("Blank", capitalize(name));
+      const base = file.base
+        .replaceAll("blank", name)
+        .replaceAll("Blank", capitalize(name));
+
+      return {
+        ...file,
+        content,
+        base,
+      };
+    }
+  );
+
+  await filesystem.copyFiles([join(cwd, "src/commands/index.ts")], (file) => {
+    const content = file.content
+      .replace(
+        "\n\nexport default",
+        `\nimport ${name} from "./${name}";\n\nexport default`
+      )
+      .replace("];\n", `  ${name},\n];\n`);
+
+    return {
+      ...file,
+      content,
+    };
+  });
+};

package/src/commands/generate/generateProject.ts

@@ -0,0 +1,115 @@
+import { filesystem } from "src/scripts/filesystem";
+import { git } from "src/scripts/git";
+import { log } from "./log";
+import { commandExists } from "src/utils/common";
+import { cmd, executeCmd } from "src/scripts/cmd";
+import { GenerateOptions } from "./GenerateOptions";
+import { confirmQuestion } from "src/utils";
+
+export const generateProject = async (
+  name: string,
+  cwd: string,
+  options: GenerateOptions
+) => {
+  const { starter = "base", noRepo, keepHistory, yes } = options;
+
+  log.verbose("Check if project name is valid");
+  if (!name.match(/^[a-z0-9-]+$/)) {
+    log.error(
+      "Project name must be lowercase, alphanumeric, and contain hyphens only."
+    );
+    return;
+  }
+
+  if (!noRepo) {
+    // Check if gh is installed
+    if (executeCmd("gh --version").status !== 0) {
+      const installGh = await confirmQuestion(
+        "GitHub cli is not installed. Do you want to install it now? (brew install gh)",
+        yes
+      );
+      if (installGh) {
+        executeCmd("brew install gh");
+      } else {
+        log.error(
+          "You must have GitHub cli installed to generate a project and create a repo."
+        );
+        return;
+      }
+    }
+
+    // Check if gh user is authenticated
+    if (executeCmd("gh auth status").status !== 0) {
+      const authenticateGh = await confirmQuestion(
+        "GitHub cli is not authenticated. Do you want to authenticate now? (gh auth login)",
+        yes
+      );
+      if (authenticateGh) {
+        executeCmd("gh auth login");
+      } else {
+        log.error(
+          "You must authenticate with GitHub cli before generating a project in order to create the repo."
+        );
+        return;
+      }
+    }
+  } else {
+    log.verbose("Skipping gh verification");
+  }
+
+  log.verbose("Cloning gluhar project template");
+  git.clone("gluharry/starters", name, { branch: starter });
+
+  cmd.cd(name);
+
+  log.verbose("Replacing gluhar-app with project's name");
+  await filesystem.copyFiles(
+    [
+      "./package.json",
+      "./README.md",
+      "./nuxt.config.ts",
+      "./sanity/sanity.config.ts",
+      "./sanity/structure.ts",
+    ],
+    (file) => {
+      const content = file.content.replaceAll("gluhar-app", name);
+
+      return {
+        ...file,
+        content,
+      };
+    }
+  );
+
+  if (!keepHistory) {
+    log.verbose("Removing git history");
+    executeCmd("rm -rf .git");
+
+    log.verbose("Initializing empty git repo with initial flat commit");
+    executeCmd(
+      "git init --initial-branch=dev && git add . && git commit -m 'Initial commit'"
+    );
+  } else {
+    log.verbose("Keeping git history and removing remote origin");
+    executeCmd("git remote remove origin && git branch -m dev");
+  }
+
+  if (!noRepo) {
+    log.verbose("Creating new github remote repo");
+    executeCmd(`gh repo create ${name} --private --source=. --push`);
+  } else {
+    log.verbose(
+      "Skipping repo creation and deleting .git. You are on your own."
+    );
+    executeCmd("rm -rf .git");
+  }
+
+  const openCode = await confirmQuestion(
+    `Project '${name}' was created successfully! Do you want to open it in VSCode/Cursor?`,
+    yes
+  );
+  if (openCode) {
+    const editorCommand = commandExists("cursor") ? "cursor" : "code";
+    executeCmd(`${editorCommand} . -g README.md`);
+  }
+};

package/src/commands/generate/index.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import { generate } from "./generate";
+import { generateTypes } from "./GenerateOptions";
+
+export default new Command()
+  .name("generate")
+  .argument("<type>", "What to generate.")
+  .argument("<name>", "Name of generated thing.")
+  .description(`Generate a ${generateTypes.join(", ")}.`)
+  .option(
+    "--starter <branchName>",
+    "When generating a project, which starter template to use: base, mobile."
+  )
+  .option("-nr, --no-repo", "Do not create a github repo automatically.")
+  .option(
+    "-kh, --keep-history",
+    "Keep commit history from the starter template."
+  )
+  .action(generate);

package/src/commands/generate/log.ts

@@ -0,0 +1,3 @@
+import { logger } from "src/utils";
+
+export const log = logger("generate");