task-script-support-cli 0.1.1 → 0.2.3

package/dist/assets/yargs-template/task-runner/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "task-runner",
+  "version": "0.1.0",
+  "main": "index.js",
+  "type": "commonjs",
+  "scripts": {
+    "start": "jiti src/index.ts",
+    "dev": "npm run build && node dist/src/index.js",
+    "clean": "rm -rf ./dist",
+    "lint": "eslint --config eslint.config.ts",
+    "watch": "onchange './*{.json,.sh,.ts}' 'src/*.ts' -- npm run build",
+    "format": "prettier --write ./",
+    "format-check": "prettier --check .",
+    "hooks-one-time-setup": "npx simple-git-hooks",
+    "prettier-watch": "onchange \"**/*\" -- prettier --write --ignore-unknown {{changed}}",
+    "build": "rm -rf ./dist && npx tsc && node dist/src/index.js -v",
+    "test": "vitest run",
+    "test-watch": "vitest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "simple-git-hooks": {
+    "pre-commit": "npx pretty-quick --staged && npm run lint"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "dotenv": "^17.2.3",
+    "figlet": "^1.9.4",
+    "immutable": "^5.1.4",
+    "reflect-metadata": "^0.2.2",
+    "task-script-support": "^2.3.0",
+    "tsyringe": "^4.10.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.3",
+    "@types/node": "^24.10.1",
+    "@types/yargs": "^17.0.35",
+    "eslint": "^10.0.3",
+    "jiti": "^2.6.1",
+    "onchange": "^7.1.0",
+    "prettier": "^3.7.1",
+    "pretty-quick": "^4.2.2",
+    "simple-git-hooks": "^2.13.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.0",
+    "vitest": "^4.0.15"
+  }
+}

package/dist/assets/yargs-template/task-runner/src/commands/verify.ts

@@ -0,0 +1,10 @@
+import { singleton } from "tsyringe";
+import { Command } from "../wrappers/command";
+import CheckEnv from "../tasks/check-env";
+import PrintBanner from "../tasks/print-banner";
+import LogState from "../tasks/log-state";
+
+@singleton()
+export class VerifyCommand extends Command {
+  tasks = [PrintBanner, CheckEnv, LogState];
+}

package/dist/assets/yargs-template/task-runner/src/index.ts

@@ -0,0 +1,46 @@
+import "reflect-metadata";
+
+import dotenv from "dotenv";
+import { container } from "tsyringe";
+
+dotenv.config({ quiet: true });
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+import { initializeInjectables } from "./wrappers/dependencies";
+initializeInjectables();
+
+import { UtilService } from "./services/util-service";
+import { VerifyCommand } from "./commands/verify";
+
+const name = UtilService.getAppName();
+
+yargs(hideBin(process.argv))
+  .usage(`${UtilService.titleizeAll(name)} CLI Client`)
+  .command(
+    "verify",
+    "check the app is working",
+    (yargs) => {
+      yargs
+        .option("bf", {
+          alias: "banner-font",
+          type: "string",
+          describe: "provide a font for the app banner",
+        })
+        .option("rf", {
+          alias: "random-font",
+          type: "boolean",
+          describe: "use a random font for app banner",
+          default: false,
+        });
+    },
+    container.resolve(VerifyCommand).handler,
+  )
+  .option("d", {
+    alias: "debug",
+    type: "boolean",
+    describe: "enable extra logging",
+    default: false,
+  })
+  .help()
+  .parse();

package/dist/assets/yargs-template/task-runner/src/services/banner-service.ts

@@ -0,0 +1,38 @@
+import { singleton } from "tsyringe";
+import figlet from "figlet";
+
+@singleton()
+export class BannerService {
+  _selectFonts = [
+    "AMC Slash",
+    "Calvin S",
+    "Bell",
+    "Pagga",
+    "Shadow",
+    "Small Block",
+  ];
+  defaultFontFamily: string = "Cybermedium";
+
+  async toBanner(text: string, font?: string): Promise<string> {
+    return await figlet.text(text, {
+      font: font || this.defaultFontFamily,
+    });
+  }
+
+  async getSupportedFonts(): Promise<string[]> {
+    return await new Promise((res, rej) => {
+      figlet.fonts((err, fonts) =>
+        err ? rej(err) : res(fonts || ([] as string[])),
+      );
+    });
+  }
+
+  async getRandomFont(): Promise<string> {
+    const randomIndexBetween = (start = 0, end = 0) =>
+      Math.floor(Math.random() * (end - start + 1)) + start;
+
+    const bannerFonts: string[] = await this.getSupportedFonts();
+    const randomFontIndex = randomIndexBetween(0, bannerFonts.length - 1);
+    return bannerFonts[randomFontIndex] || this.defaultFontFamily;
+  }
+}

package/dist/assets/yargs-template/task-runner/src/services/log-service.ts

@@ -0,0 +1,48 @@
+import { inject, injectable } from "tsyringe";
+import { PinoLogger } from "task-script-support";
+import pino from "pino";
+
+@injectable()
+export class LogService {
+  logger: pino.Logger;
+
+  static ParentInstance?: pino.Logger;
+
+  constructor(@inject("PinoLogger") private pinoLogger: PinoLogger) {
+    if (!LogService.ParentInstance) {
+      this.logger = pinoLogger.getLogger();
+      LogService.ParentInstance = this.logger;
+    } else {
+      this.logger = LogService.ParentInstance.child({});
+    }
+  }
+
+  setPrefix(prefix: string) {
+    if (!LogService.ParentInstance) {
+      this.logger = this.pinoLogger.getLogger(prefix);
+      LogService.ParentInstance = this.logger;
+    } else {
+      this.logger = LogService.ParentInstance.child({}, { msgPrefix: prefix });
+    }
+  }
+
+  public info(msg: string, obj?: unknown): void {
+    this.logger.info(obj, msg);
+  }
+
+  public error(err: Error | string, msg?: string, obj?: unknown): void {
+    if (err instanceof Error) {
+      this.logger.error({ err, ...(obj ? obj : {}) }, msg || "Error occurred");
+    } else {
+      this.logger.error(obj, `${msg}: ${err}`);
+    }
+  }
+
+  public warn(msg: string, obj?: unknown): void {
+    this.logger.warn(obj, msg);
+  }
+
+  public debug(msg: string, obj?: unknown): void {
+    this.logger.debug(obj, msg);
+  }
+}

package/dist/assets/yargs-template/task-runner/src/services/spawn-service.ts

@@ -0,0 +1,87 @@
+import childProcess, { ChildProcess, spawn } from "node:child_process";
+import type { ProcessOutput, ProcessStatus } from "../types/process";
+import { singleton } from "tsyringe";
+
+@singleton()
+export class SpawnService {
+  execSyncFromDir(command: string, dir: string) {
+    try {
+      return childProcess.execSync(command, { cwd: dir }).toString();
+    } catch (error) {
+      console.error(`Error executing command: ${command}`);
+      throw error;
+    }
+  }
+
+  execSync(command: string) {
+    try {
+      return childProcess.execSync(command).toString();
+    } catch (error) {
+      console.error(`Error executing command: ${command}`);
+      throw error;
+    }
+  }
+
+  exec(command: string): Promise<ProcessOutput> {
+    try {
+      return new Promise((res, rej) => {
+        return childProcess.exec(command, (err, stdout, stderr) => {
+          if (err) return rej(err);
+          return res({ stdout, stderr });
+        });
+      });
+    } catch (error) {
+      console.error(`Error executing command: ${command}`, error);
+      throw error;
+    }
+  }
+
+  backgroundExec(command: string, args: string[] = []): ChildProcess {
+    const child = spawn(command, args, {
+      detached: true,
+      stdio: "ignore",
+    });
+
+    child.unref();
+    return child;
+  }
+
+  isProcessCompleted(pid: number): boolean {
+    try {
+      // sending signal 0 checks if the process exists
+      process.kill(pid, 0);
+      return false;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+      return true;
+    }
+  }
+
+  kill(pid: number) {
+    try {
+      process.kill(pid);
+    } catch (error) {
+      throw new Error(
+        `Failed to kill process with PID ${pid}: ${(error as Error).message}`,
+      );
+    }
+  }
+
+  forceKill(pid: number) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch (error) {
+      throw new Error(
+        `Failed to forcefully kill process with PID ${pid}: ${(error as Error).message}`,
+      );
+    }
+  }
+
+  async getProcessStatus(pid: number): Promise<ProcessStatus> {
+    const completed = this.isProcessCompleted(pid);
+    return {
+      pid,
+      status: completed ? "completed" : "running",
+    };
+  }
+}

package/dist/assets/yargs-template/task-runner/src/services/util-service.ts

@@ -0,0 +1,28 @@
+import { singleton } from "tsyringe";
+import pkgJson from "../../package.json";
+
+@singleton()
+export class UtilService {
+  static TITLEIZE_TEXT_BREAKPONT: RegExp = /[. _-]/g;
+
+  static titleize = (s: string) =>
+    s ? `${s[0]?.toUpperCase()}${s.slice(1, s.length)}` : s;
+  titleize = (s: string) => UtilService.titleize(s);
+
+  titleizeAll = (s: string) => UtilService.titleizeAll(s);
+  static titleizeAll = (str: string) =>
+    str
+      .trim()
+      .split(UtilService.TITLEIZE_TEXT_BREAKPONT)
+      .map(UtilService.titleize)
+      .join(" ");
+
+  static getAppName = () => pkgJson.name;
+  getAppName = () => pkgJson.name;
+
+  static getAppVersion = () => pkgJson.version;
+  getAppVersion = () => pkgJson.version;
+
+  static getAppDescription = () => pkgJson.description;
+  getAppDescription = () => pkgJson.description;
+}

package/dist/assets/yargs-template/task-runner/src/tasks/check-env.ts

@@ -0,0 +1,49 @@
+import chalk from "chalk";
+import { AppTask } from "../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+import { EnvironmentConfigKeys } from "../types/state";
+
+/**
+ * Checks the environment configuration
+ */
+@autoInjectable()
+export default class CheckEnv extends AppTask {
+  loggerName = "Check Environment";
+
+  async run() {
+    this.logger.info(chalk.blueBright("Running Check Environment"));
+
+    const errorMessages: string[] = [];
+    const requiredEnv: string[] = [];
+    const optionalEnv = [
+      EnvironmentConfigKeys.NODE_ENV,
+      EnvironmentConfigKeys.PINO_LOG_TARGET,
+      EnvironmentConfigKeys.PINO_LOG_DIR_PATH,
+      EnvironmentConfigKeys.PINO_LOG_FILENAME,
+      EnvironmentConfigKeys.PINO_LOG_LEVEL,
+    ];
+
+    [...optionalEnv, ...requiredEnv]
+      .filter((e) => !!process.env[e])
+      .forEach((e) => {
+        this.logger.info(`Read value for ${e}: ${process.env[e]}`);
+      });
+
+    requiredEnv
+      .filter((e) => !process.env[e])
+      .forEach((e) =>
+        errorMessages.push(`Missing required environment variable ${e}`),
+      );
+
+    // fail the process on bad environment
+    if (errorMessages.length) {
+      this.logger.error(
+        new Error("Misconfigured Environment"),
+        chalk.red(errorMessages.join("\n")),
+      );
+      process.exit(1);
+    }
+
+    this.state = this.setData({ environmentValidated: true });
+  }
+}

package/dist/assets/yargs-template/task-runner/src/tasks/log-state.ts

@@ -0,0 +1,22 @@
+import chalk from "chalk";
+import { AppTask } from "../wrappers/app-task";
+import { autoInjectable } from "tsyringe";
+
+/**
+ * Logs the app state
+ */
+@autoInjectable()
+export default class LogState extends AppTask {
+  loggerName = "Log State";
+  async run() {
+    if (!this.state.args.debug) {
+      this.logger.debug(
+        chalk.dim("Skipping logging state, use debug flag to see state"),
+      );
+      return;
+    }
+
+    this.logger.info(chalk.blueBright("Running Log State"));
+    this.logger.debug("state", this.state);
+  }
+}

package/dist/assets/yargs-template/task-runner/src/tasks/print-banner.ts

@@ -0,0 +1,73 @@
+import { autoInjectable } from "tsyringe";
+import { AppState } from "../types/state";
+import { AppTask } from "../wrappers/app-task";
+import { BannerService } from "../services/banner-service";
+import { UtilService } from "../services/util-service";
+import chalk from "chalk";
+
+/**
+ * Prints an app banner to the console
+ */
+@autoInjectable()
+export default class PrintBanner extends AppTask {
+  loggerName = "Print Banner";
+
+  constructor(
+    private bannnerSvc: BannerService,
+    private utilService: UtilService,
+  ) {
+    super();
+  }
+
+  async preRun() {
+    await this.validateFont();
+  }
+
+  async run({ args }: AppState): Promise<Partial<AppState> | void> {
+    let font = "";
+
+    try {
+      if (args.randomFont) {
+        font = await this.bannnerSvc.getRandomFont();
+        console.log(`Using random font ${font}`);
+      }
+
+      // allow banner-font as user input
+      if (args.bannerFont) {
+        font = args.bannerFont;
+      }
+
+      console.log(
+        chalk.blueBright(
+          await this.bannnerSvc.toBanner(this.utilService.getAppName(), font),
+        ),
+      );
+
+      // mutate state
+      this.setData({
+        banner: { font: font || this.bannnerSvc.defaultFontFamily },
+      });
+
+      // return updated state instead of calling setData
+      return { data: { banner: { status: "success" } } } as const;
+    } catch (err) {
+      this.setData({ banner: { status: "failed" }, errorMessages: [`${err}`] });
+    }
+  }
+
+  /*
+    Helper for ensuring font is supported if provided as input
+  */
+  async validateFont() {
+    const { args } = this.state;
+    if (!args.bannerFont) {
+      return;
+    }
+
+    const fontName = args.bannerFont;
+    const availableFonts = await this.bannnerSvc.getSupportedFonts();
+    if (!availableFonts.includes(fontName)) {
+      throw new Error(`Unsupported font provided: ${chalk.red(fontName)}`);
+    }
+  }
+}

package/dist/assets/yargs-template/task-runner/src/types/process.ts

@@ -0,0 +1,9 @@
+export interface ProcessStatus {
+  readonly pid: number;
+  readonly status: "running" | "completed" | "unknown";
+}
+
+export interface ProcessOutput {
+  stdout?: string;
+  stderr?: string;
+}

package/dist/assets/yargs-template/task-runner/src/types/state.ts

@@ -0,0 +1,31 @@
+import { AppState as State } from "task-script-support";
+
+// Add app data here as needed. Use readonly for immutable fields.
+//
+// Note: this object gets passed to deepMerge upon updating app state
+// which also merges array fields. This might be fine or you might want
+// to make your arrays <type>[] | undefined to allow clobbering.
+export interface AppStateData {
+  readonly errorMessages?: string[];
+  readonly banner?: {
+    readonly status?: "success" | "failed";
+    readonly font?: string;
+  };
+  readonly environmentValidated?: boolean;
+}
+
+export type CLIArgs = {
+  readonly debug: boolean;
+  readonly randomFont: boolean;
+  readonly bannerFont?: string;
+};
+
+export type AppState = State<AppStateData, CLIArgs>;
+
+export const EnvironmentConfigKeys = {
+  PINO_LOG_DIR_PATH: "PINO_LOG_DIR_PATH",
+  PINO_LOG_LEVEL: "PINO_LOG_LEVEL",
+  NODE_ENV: "NODE_ENV",
+  PINO_LOG_FILENAME: "PINO_LOG_FILENAME",
+  PINO_LOG_TARGET: "PINO_LOG_TARGET",
+};

package/dist/assets/yargs-template/task-runner/src/wrappers/app-task.ts

@@ -0,0 +1,42 @@
+import { autoInjectable } from "tsyringe";
+import { CommandService, Task } from "task-script-support";
+import { LogService } from "../services/log-service";
+import type { AppState, AppStateData, CLIArgs } from "../types/state";
+
+@autoInjectable()
+export class AppTask extends Task<AppStateData, CLIArgs> {
+  state: AppState = {
+    id: "uninitialized",
+    args: {} as CLIArgs,
+    data: {},
+  };
+  loggerName: string = "";
+
+  get logger(): LogService {
+    return this._logService!;
+  }
+
+  constructor(
+    public _logService?: LogService,
+    public _commandService?: CommandService<AppStateData, CLIArgs>,
+  ) {
+    super();
+  }
+
+  //@override
+  async initialize() {
+    if (this.loggerName) {
+      this.logger!.setPrefix(`${this.loggerName} :: `);
+    }
+  }
+
+  //@override
+  async run(state: AppState): Promise<Partial<AppState> | void> {
+    throw new Error(`run not implemented (${state.id})`);
+  }
+
+  setData(data: Partial<AppStateData>) {
+    this.state = this._commandService!.setData(this.state, data);
+    return this.state;
+  }
+}

package/dist/assets/yargs-template/task-runner/src/wrappers/command.ts

@@ -0,0 +1,20 @@
+import { CommandService, TaskClass } from "task-script-support";
+import { inject } from "tsyringe";
+import { AppStateData, CLIArgs } from "../types/state";
+
+export class Command {
+  tasks: TaskClass<AppStateData, CLIArgs>[] = [];
+
+  constructor(
+    @inject(CommandService<AppStateData, CLIArgs>)
+    private commandService: CommandService<AppStateData, CLIArgs>,
+  ) {}
+
+  get handler(): (...cliArgs: unknown[]) => Promise<void> {
+    return this.commandService.fromTasks(this.getTasks());
+  }
+
+  getTasks(): TaskClass<AppStateData, CLIArgs>[] {
+    return this.tasks;
+  }
+}

package/dist/assets/yargs-template/task-runner/src/wrappers/dependencies.ts

@@ -0,0 +1,24 @@
+import { CommandService, PinoLogger } from "task-script-support";
+import { container } from "tsyringe";
+import { AppStateData, CLIArgs } from "../types/state";
+
+/**
+ * Register external dependencies as injectables
+ */
+export const initializeInjectables = () => {
+  // register command service
+  container.registerSingleton(CommandService<AppStateData, CLIArgs>);
+
+  // configure args provider
+  const command = container.resolve(CommandService<AppStateData, CLIArgs>);
+  command.argsProvider = (...yargsArgs: unknown[]) => {
+    const args = command.argsProvider_Yargs(...yargsArgs);
+
+    // and register args
+    container.registerInstance("Args", args);
+    return args;
+  };
+
+  // register pino
+  container.registerInstance("PinoLogger", new PinoLogger());
+};

package/dist/assets/yargs-template/task-runner/task-runner

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+npm start -- "$@"

package/dist/assets/yargs-template/task-runner/templater.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+set -euo pipefail
+
+if [[ -z "$1" ]]; then
+  echo "Missing required parameter. Usage: ./templater.sh <output-name>"
+  exit 1;
+fi
+
+DIR_LIST_TO_COPY=('.vscode' 'src' 'tests')
+FILE_LIST_TO_COPY=('.gitignore' '.prettierignore' '.prettierrc' 'task-runner' 'install-link.sh' 'eslint.config.ts' 'vitest.config.ts' 'package-lock.json' 'package.json' 'tsconfig.json')
+NAME_REF_LIST=('package.json' 'package-lock.json' 'install-link.sh')
+CWD=$(pwd)
+SCRIPT_DIR=$(dirname "$0")
+DESTINATION="$CWD/$1"
+
+# ensure dest exists
+if [ -f "$DESTINATION" ]; then
+  echo "Using destination: $DESTINATION"
+else
+  echo "Creating destination directory: $DESTINATION"
+  mkdir -p "$DESTINATION"
+fi
+
+# copy directories
+for folder in "${DIR_LIST_TO_COPY[@]}"; do
+  echo "Running Copy/: cp -R $SCRIPT_DIR/$folder $DESTINATION/$folder"
+  cp -R "$SCRIPT_DIR/$folder" "$DESTINATION/$folder"
+done
+
+# copy files
+for filename in "${FILE_LIST_TO_COPY[@]}"; do
+  echo "Running Copy: cp $SCRIPT_DIR/$filename $DESTINATION/$filename"
+  cp "$SCRIPT_DIR/$filename" "$DESTINATION/$filename"
+done
+
+# fix naming
+for fileToEdit in "${NAME_REF_LIST[@]}"; do
+  dest="$DESTINATION/$fileToEdit"
+  replace_pattern="s/task-runner/$1/g"
+  echo "Running Patch: cat \"$dest\" | sed -i \"$replace_pattern\" "
+  output=$(cat "$dest" | sed "$replace_pattern")
+  echo "$output" > "$dest"
+
+  # echo "Running patch: sed -i \"s/task-runner/$1/g\" \"$DESTINATION/$fileToEdit\""
+  # sed -i "s/task-runner/$1/g" "$DESTINATION/$fileToEdit"
+done
+mv "$DESTINATION/task-runner" "$DESTINATION/$1"
+
+
+# cd into destination and run git init
+echo "initializing with git"
+INITIALIZED=$(cd "$DESTINATION" && git init -b main)
+
+echo;
+echo "   Try:"
+echo "         cd $DESTINATION && npm i && npm run dev"
+echo;