taskforge-cli 0.0.1

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nirvik Purkait
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# Why `taskforge-cli`
+
+Have you ever been frustrated of changing `env` variable for stanalone projects, where no build tools are used, or doesnot support loading `env` variables out of the box, and you Have to use packages like `dotenv`.
+
+One down side is that for each mode (development / test / production), you have to keep changing the values according to the mode. Well `taskforge-cli` lets you do that out of the box.
+
+You can achieve this with the help of a config file `tf.config.ts|js`, and as well as cli options.
+
+## Config file
+
+In config file you can `defult` export an `Config` object or a `defineConfig()` function which takes an object as a parameter or a function that returns an object as a parameter.
+
+## How to use it
+
+```json
+// package.json
+
+...
+  "scripts": {
+    "build": "tf build",                            // predefined script dev | build | test
+    "foo": "tf custom foo",                         // custom script needs a "custom" keyword
+    "bar": "tf custom bar",                         // custom script needs a "custom" keyword
+    "bazz": "tf custom bazz --envFile ./.env.bazz", // custom script, loads ".env.bazz"
+  },
+...
+```
+
+```ts
+export default defineConfig({
+  scripts: {
+    build: {
+      execute: "node index.ts", // loads production env
+    },
+    foo: {
+      execute: "node foo.ts", // loads ".env" by default unless specified
+    },
+    bar: {
+      execute: "node bar.ts", // loads ".env.bar"
+      envFile: "./env/.env.bar",
+    },
+  },
+});
+```
+
+## Options:
+
+### Config:
+
+**cli option**: `--config`
+
+**alias**: `-c`
+
+**type**: `string`
+
+**defult**: `process.cwd()`
+
+If your config file is not at the root of your project, provide a relative path to the config file.
+
+### Env file:
+
+**cli option**: `--envFile`
+
+**type**: `string`
+
+Pass a specific env file for that script.
+
+### Env directory:
+
+**cli option**: `--envDir`
+
+**type**: `string`
+
+Pass a directory where your env files lives. It will load preferred `env` file depending on the script type.
+
+If script is predefined i.e: dev | build | test, it will laod related `env` file, and if the script is custom it will load defult `.env` file.
+
+### Executing command:
+
+**cli option**: `--exec`
+
+**type**: `string`
+
+Pass a command that should execute for that script.

package/dist/bin/index.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+'use strict';
+
+var jiti = require('jiti');
+var node_process = require('node:process');
+var dotenv = require('dotenv');
+var path = require('node:path');
+var node_fs = require('node:fs');
+var config = require('../config-qD-eCtlL.js');
+var node_child_process = require('node:child_process');
+require('zod');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const validConfigFilesOrder = [
+  "tf.config.ts",
+  "tf.config.js",
+  "tf.config.mjs",
+  "tf.config.cjs"
+];
+const productionEnvFileLoadingOrder = [
+  ".env.production.local",
+  ".env.production",
+  ".env.local",
+  ".env"
+];
+const developmentEnvFileLoadingOrder = [
+  ".env.development.local",
+  ".env.development",
+  ".env.local",
+  ".env"
+];
+const testEnvFileLoadingOrder = [
+  ".env.test.local",
+  ".env.test",
+  ".env.local",
+  ".env"
+];
+
+const passedArguments = node_process.argv.slice(2);
+function identifyScript() {
+  if (passedArguments.includes("dev")) {
+    return "dev";
+  } else if (passedArguments.includes("build")) {
+    return "build";
+  } else if (passedArguments.includes("test")) {
+    return "test";
+  } else if (passedArguments.includes("custom")) {
+    return passedArguments[passedArguments.findIndex((value) => value === "custom") + 1];
+  } else
+    throw new Error(
+      'No script is passed.\nIf you have a custom scripts other than predefined scripts use "tf custom <script-name>".\nRemember the script name must be next to the custom keyword'
+    );
+}
+const scriptName = identifyScript();
+function loadEnvFile() {
+  let envFilePath;
+  if (scriptName === "dev") {
+    envFilePath = availableFile(
+      developmentEnvFileLoadingOrder,
+      finalConfig?.envDir ?? finalConfig?.scripts?.dev?.envDir ?? process.cwd()
+    );
+    if (finalConfig?.scripts?.dev?.envFile) {
+      envFilePath = finalConfig.scripts.dev.envFile;
+    }
+  } else if (scriptName === "build") {
+    envFilePath = availableFile(
+      productionEnvFileLoadingOrder,
+      finalConfig?.envDir ?? finalConfig?.scripts?.build?.envDir ?? process.cwd()
+    );
+    if (finalConfig?.scripts?.build?.envFile) {
+      envFilePath = finalConfig.scripts.build.envFile;
+    }
+  } else if (scriptName === "test") {
+    envFilePath = availableFile(
+      testEnvFileLoadingOrder,
+      finalConfig?.envDir ?? finalConfig?.scripts?.test?.envDir ?? process.cwd()
+    );
+    if (finalConfig?.scripts?.test?.envFile) {
+      envFilePath = finalConfig.scripts.test.envFile;
+    }
+  } else {
+    envFilePath = path.join(
+      finalConfig?.envDir ?? finalConfig?.scripts?.[scriptName]?.envDir ?? process.cwd(),
+      ".env"
+    );
+    if (finalConfig?.scripts?.[scriptName]?.envFile) {
+      envFilePath = finalConfig.scripts?.[scriptName].envFile;
+    }
+  }
+  if (!envFilePath || !node_fs.existsSync(envFilePath) || !node_fs.statSync(envFilePath).isFile()) {
+    console.log(`No env file detected.
+Skipping loading env variables`);
+    return;
+  }
+  process.env.NODE_ENV = scriptName === "dev" ? "development" : scriptName === "build" ? "production" : scriptName === "test" ? "test" : void 0;
+  dotenv.config({ path: envFilePath, quiet: true, override: true });
+}
+function availableFile(fileOrder, scanningDir) {
+  return fileOrder.map((f) => path.join(scanningDir, f)).find((f) => node_fs.existsSync(f));
+}
+const arbitaryArgumets = [];
+function extractCliOptions() {
+  let cliOptions2 = {};
+  passedArguments.forEach((arg, idx) => {
+    if (!(arg === scriptName || arg === "custom")) {
+      arbitaryArgumets.push(arg);
+    }
+    if (arg === "-c" || arg === "--config") {
+      cliOptions2.configFileLocation = passedArguments[idx + 1];
+      arbitaryArgumets.pop();
+    }
+    if (arg.startsWith("-c=") || arg.startsWith("--config=")) {
+      cliOptions2.configFileLocation = arg.split("=")[1];
+      arbitaryArgumets.pop();
+    }
+    if (arg === "--envFile") {
+      cliOptions2.envFile = passedArguments[idx + 1];
+      arbitaryArgumets.pop();
+    }
+    if (arg.startsWith("--envFile=")) {
+      cliOptions2.envFile = arg.split("=")[1];
+      arbitaryArgumets.pop();
+    }
+    if (arg === "--envDir") {
+      cliOptions2.envDir = passedArguments[idx + 1];
+      arbitaryArgumets.pop();
+    }
+    if (arg.startsWith("--envDir=")) {
+      cliOptions2.envDir = arg.split("=")[1];
+      arbitaryArgumets.pop();
+    }
+    if (arg === "--exec") {
+      cliOptions2.execute = passedArguments[idx + 1];
+      arbitaryArgumets.pop();
+    }
+    if (arg.startsWith("--exec=")) {
+      cliOptions2.execute = arg.split("=")[1];
+      arbitaryArgumets.pop();
+    }
+  });
+  if (Object.keys(cliOptions2).length === 0) {
+    return void 0;
+  }
+  return cliOptions2;
+}
+const cliOptions = extractCliOptions();
+const scriptRelatedCliOptions = { ...cliOptions };
+delete scriptRelatedCliOptions?.configFileLocation;
+function executeConfigFile() {
+  const determinedConfigFileLocation = cliOptions?.configFileLocation ?? availableFile(validConfigFilesOrder, process.cwd());
+  if (!determinedConfigFileLocation) {
+    console.log("No config file found");
+    return;
+  }
+  const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bin/index.js', document.baseURI).href)), {
+    interopDefault: true
+  });
+  const moduleFromConfigFile = jiti$1(path.resolve(determinedConfigFileLocation));
+  const config2 = moduleFromConfigFile?.default ?? moduleFromConfigFile;
+  const parsedConfig = config.configSchema.safeParse(config2);
+  if (!parsedConfig.success) {
+    throw new Error("Something is wrong with config file. Please correct it");
+  }
+  return parsedConfig.data;
+}
+const configurationFromConfigFile = executeConfigFile();
+const scriptsDetailsFromConfigFile = configurationFromConfigFile?.scripts;
+const scriptsFromConfig = scriptsDetailsFromConfigFile ?? {};
+const mergedScriptDetails = {
+  ...scriptsFromConfig,
+  [scriptName]: {
+    ...scriptsFromConfig[scriptName] ?? {},
+    ...scriptRelatedCliOptions
+  }
+};
+const finalConfig = {
+  ...configurationFromConfigFile,
+  scripts: { ...mergedScriptDetails }
+};
+
+loadEnvFile();
+if (finalConfig?.scripts?.[scriptName]?.execute) {
+  const executableCommand = finalConfig?.scripts?.[scriptName]?.execute.split(" ");
+  const executable = executableCommand[0];
+  const command = executableCommand.slice(1).concat(arbitaryArgumets);
+  const process = node_child_process.spawn(executable, command, {
+    stdio: ["inherit", "pipe", "pipe"],
+    shell: true
+  });
+  process.stdout.on("data", (chunk) => {
+    console.log(chunk.toString());
+  });
+  process.stderr.on("data", (chunk) => {
+    console.error(chunk.toString());
+  });
+  process.on("exit", (code, signal) => {
+    console.log(`Process exited with code ${code}, signal ${signal}`);
+  });
+}

package/dist/config-BKNe73ub.mjs

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+const configSchema = z.object({
+  envDir: z.string().optional(),
+  scripts: z.custom().optional()
+}).optional();
+function defineConfig(config) {
+  if (typeof config === "function") {
+    return config();
+  }
+  return config;
+}
+
+export { configSchema as c, defineConfig as d };

package/dist/config-qD-eCtlL.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var zod = require('zod');
+
+const configSchema = zod.z.object({
+  envDir: zod.z.string().optional(),
+  scripts: zod.z.custom().optional()
+}).optional();
+function defineConfig(config) {
+  if (typeof config === "function") {
+    return config();
+  }
+  return config;
+}
+
+exports.configSchema = configSchema;
+exports.defineConfig = defineConfig;

package/dist/config-qD-eCtlL.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var zod = require('zod');
+
+const configSchema = zod.z.object({
+  envDir: zod.z.string().optional(),
+  scripts: zod.z.custom().optional()
+}).optional();
+function defineConfig(config) {
+  if (typeof config === "function") {
+    return config();
+  }
+  return config;
+}
+
+exports.configSchema = configSchema;
+exports.defineConfig = defineConfig;

package/dist/exports/config.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+var config = require('../config-qD-eCtlL.cjs');
+require('zod');
+
+
+
+exports.defineConfig = config.defineConfig;

package/dist/exports/config.d.cts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+
+type ScriptDetails = {
+    envFile?: string;
+    execute: string;
+    envDir?: string;
+};
+type Scripts = {
+    dev?: ScriptDetails;
+    build?: ScriptDetails;
+    test?: ScriptDetails;
+} & Record<string, ScriptDetails>;
+declare const configSchema: z.ZodOptional<z.ZodObject<{
+    envDir: z.ZodOptional<z.ZodString>;
+    scripts: z.ZodOptional<z.ZodCustom<Scripts, Scripts>>;
+}, z.core.$strip>>;
+type Config = z.infer<typeof configSchema>;
+/**
+ * Defines and validates the CLI configuration.
+ *
+ * This helper enables strong typing and IDE autocomplete when
+ * authoring configuration files. It accepts either a plain
+ * configuration object or a factory function that returns one.
+ *
+ * When a function is provided, it is executed immediately and
+ * its return value is used as the final configuration.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from "taskforge/config";
+ *
+ * export default defineConfig({
+ *   envDir: ".",
+ *   scripts: {
+ *     build: {
+ *       execute: "tsc"
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * export default defineConfig(() => ({
+ *   scripts: {
+ *     dev: "pnpm dev"
+ *   }
+ * }));
+ * ```
+ *
+ * @param config - Configuration object or a function returning it
+ * @returns The resolved configuration object
+ */
+declare function defineConfig(config: Config | (() => Config)): {
+    envDir?: string | undefined;
+    scripts?: Scripts | undefined;
+} | undefined;
+
+export { defineConfig };
+export type { Config };

package/dist/exports/config.d.mts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+
+type ScriptDetails = {
+    envFile?: string;
+    execute: string;
+    envDir?: string;
+};
+type Scripts = {
+    dev?: ScriptDetails;
+    build?: ScriptDetails;
+    test?: ScriptDetails;
+} & Record<string, ScriptDetails>;
+declare const configSchema: z.ZodOptional<z.ZodObject<{
+    envDir: z.ZodOptional<z.ZodString>;
+    scripts: z.ZodOptional<z.ZodCustom<Scripts, Scripts>>;
+}, z.core.$strip>>;
+type Config = z.infer<typeof configSchema>;
+/**
+ * Defines and validates the CLI configuration.
+ *
+ * This helper enables strong typing and IDE autocomplete when
+ * authoring configuration files. It accepts either a plain
+ * configuration object or a factory function that returns one.
+ *
+ * When a function is provided, it is executed immediately and
+ * its return value is used as the final configuration.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from "taskforge/config";
+ *
+ * export default defineConfig({
+ *   envDir: ".",
+ *   scripts: {
+ *     build: {
+ *       execute: "tsc"
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * export default defineConfig(() => ({
+ *   scripts: {
+ *     dev: "pnpm dev"
+ *   }
+ * }));
+ * ```
+ *
+ * @param config - Configuration object or a function returning it
+ * @returns The resolved configuration object
+ */
+declare function defineConfig(config: Config | (() => Config)): {
+    envDir?: string | undefined;
+    scripts?: Scripts | undefined;
+} | undefined;
+
+export { defineConfig };
+export type { Config };

package/dist/exports/config.mjs

@@ -0,0 +1,2 @@
+export { d as defineConfig } from '../config-BKNe73ub.mjs';
+import 'zod';

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "taskforge-cli",
+  "version": "0.0.1",
+  "description": "A cli tool to leverage env related headache",
+  "lint-staged": {
+    "src/**/*.ts": "pnpm format"
+  },
+  "scripts": {
+    "prebuild": "rimraf ./dist",
+    "build": "pkgroll",
+    "format": "prettier --write src/**/*.ts",
+    "test": "tsx --test",
+    "pre-commit": "lint-staged"
+  },
+  "bin": {
+    "tf": "dist/bin/index.js"
+  },
+  "exports": {
+    "./config": {
+      "require": {
+        "types": "./dist/exports/config.d.cts",
+        "default": "./dist/exports/config.cjs"
+      },
+      "import": {
+        "types": "./dist/exports/config.d.mts",
+        "default": "./dist/exports/config.mjs"
+      }
+    }
+  },
+  "keywords": [],
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nirvikpurkait/taskforge-cli.git"
+  },
+  "contributors": [
+    {
+      "email": "nirvikpurkait@gamil.com",
+      "name": "Nirvik Purkait"
+    }
+  ],
+  "bugs": {
+    "url": "https://github.com/nirvikpurkait/taskforge-cli/issues"
+  },
+  "homepage": "https://github.com/nirvikpurkait/taskforge-cli",
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.20.0",
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "jiti": "^2.6.1",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "pkgroll": "^2.21.4",
+    "prettier": "^3.7.4",
+    "rimraf": "^6.1.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}