taskforge-cli 0.0.1 → 1.0.0

package/LICENCE

@@ -1,21 +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.
+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

@@ -1,83 +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.
+# 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
+
+```
+// package.json
+
+...
+  "scripts": {
+    "build": "tf build",                            // predefined script dev | build | test
+    "foo": "tf run foo",                         // custom script needs a "run" keyword
+    "bar": "tf run bar",                         // custom script needs a "run" keyword
+    "bazz": "tf run 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 file location:
+
+**cli option**: `--config`
+
+**alias**: `-c`
+
+**type**: `string`
+
+**defult**: `./tf.config.js|cjs|mjs|ts`
+
+If your config file is not at the root of your project, provide a relative path to the config file. i.e: `../config/tf.config.ts`
+
+### 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

@@ -1,12 +1,12 @@
 #!/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 jiti = require('jiti');
+var node_process = require('node:process');
+var dotenv = require('dotenv');
 var node_child_process = require('node:child_process');
 require('zod');
 
@@ -35,165 +35,217 @@ const testEnvFileLoadingOrder = [
   ".env.local",
   ".env"
 ];
+const defaultEnvFileLoadingOrder = [
+  //
+  ".env.local",
+  ".env"
+];
 
-const passedArguments = node_process.argv.slice(2);
-function identifyScript() {
+function identifyScript(passedArguments) {
   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 if (passedArguments.includes("run")) {
+    return passedArguments[passedArguments.findIndex((value) => value === "run") + 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'
+      'No script is passed.\nIf you have a custom scripts other than predefined scripts use "tf run <script-name>".\nRemember, the script name must be next to the `run` 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;
+function availableEnvFile({
+  scriptName,
+  scanningDir
+}) {
+  if (!scanningDir) {
+    if (scriptName === "dev") {
+      return resolveEnvFile(developmentEnvFileLoadingOrder, "");
     }
-  } 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;
+    if (scriptName === "build") {
+      return resolveEnvFile(productionEnvFileLoadingOrder, "");
     }
-  } 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 (scriptName === "test") {
+      return resolveEnvFile(testEnvFileLoadingOrder, "");
     }
+    return resolveEnvFile(defaultEnvFileLoadingOrder, "");
   }
-  if (!envFilePath || !node_fs.existsSync(envFilePath) || !node_fs.statSync(envFilePath).isFile()) {
-    console.log(`No env file detected.
-Skipping loading env variables`);
-    return;
+  if (scriptName === "dev") {
+    return resolveEnvFile(developmentEnvFileLoadingOrder, scanningDir);
+  }
+  if (scriptName === "build") {
+    return resolveEnvFile(productionEnvFileLoadingOrder, scanningDir);
+  }
+  if (scriptName === "test") {
+    return resolveEnvFile(testEnvFileLoadingOrder, scanningDir);
+  }
+  return resolveEnvFile(defaultEnvFileLoadingOrder, scanningDir);
+  function resolveEnvFile(fileOrder, dir) {
+    for (const file of fileOrder) {
+      const fullPath = path.join(dir, file);
+      if (node_fs.existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+    return null;
   }
-  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 = {};
+function extractCliOptions(passedArguments) {
+  const arbitaryCliArgumets = [];
+  const scriptName = identifyScript(passedArguments);
+  let shouldSkipNextArgument = false;
+  let cliOptions = {};
   passedArguments.forEach((arg, idx) => {
-    if (!(arg === scriptName || arg === "custom")) {
-      arbitaryArgumets.push(arg);
+    if (!(arg === scriptName || arg === "run")) {
+      arbitaryCliArgumets.push(arg);
+      if (shouldSkipNextArgument) {
+        arbitaryCliArgumets.pop();
+        shouldSkipNextArgument = !shouldSkipNextArgument;
+      }
     }
     if (arg === "-c" || arg === "--config") {
-      cliOptions2.configFileLocation = passedArguments[idx + 1];
-      arbitaryArgumets.pop();
+      cliOptions.configFileLocation = passedArguments[idx + 1];
+      arbitaryCliArgumets.pop();
+      shouldSkipNextArgument = true;
     }
     if (arg.startsWith("-c=") || arg.startsWith("--config=")) {
-      cliOptions2.configFileLocation = arg.split("=")[1];
-      arbitaryArgumets.pop();
+      cliOptions.configFileLocation = arg.split("=")[1];
+      arbitaryCliArgumets.pop();
     }
     if (arg === "--envFile") {
-      cliOptions2.envFile = passedArguments[idx + 1];
-      arbitaryArgumets.pop();
+      cliOptions.envFile = passedArguments[idx + 1];
+      arbitaryCliArgumets.pop();
+      shouldSkipNextArgument = true;
     }
     if (arg.startsWith("--envFile=")) {
-      cliOptions2.envFile = arg.split("=")[1];
-      arbitaryArgumets.pop();
+      cliOptions.envFile = arg.split("=")[1];
+      arbitaryCliArgumets.pop();
     }
     if (arg === "--envDir") {
-      cliOptions2.envDir = passedArguments[idx + 1];
-      arbitaryArgumets.pop();
+      cliOptions.envDir = passedArguments[idx + 1];
+      arbitaryCliArgumets.pop();
+      shouldSkipNextArgument = true;
     }
     if (arg.startsWith("--envDir=")) {
-      cliOptions2.envDir = arg.split("=")[1];
-      arbitaryArgumets.pop();
+      cliOptions.envDir = arg.split("=")[1];
+      arbitaryCliArgumets.pop();
     }
     if (arg === "--exec") {
-      cliOptions2.execute = passedArguments[idx + 1];
-      arbitaryArgumets.pop();
+      cliOptions.execute = passedArguments[idx + 1];
+      arbitaryCliArgumets.pop();
+      shouldSkipNextArgument = true;
     }
     if (arg.startsWith("--exec=")) {
-      cliOptions2.execute = arg.split("=")[1];
-      arbitaryArgumets.pop();
+      cliOptions.execute = arg.split("=")[1];
+      arbitaryCliArgumets.pop();
+    }
+    if (arg === "--shell") {
+      const passedArgument = passedArguments[idx + 1];
+      if (passedArgument === "false") cliOptions.shell = false;
+      if (passedArgument === "true") cliOptions.shell = true;
+      cliOptions.execute = passedArgument;
+      arbitaryCliArgumets.pop();
+      shouldSkipNextArgument = true;
+    }
+    if (arg.startsWith("--shell=")) {
+      const passedArgument = arg.split("=")[1];
+      if (passedArgument === "false") cliOptions.shell = false;
+      if (passedArgument === "true") cliOptions.shell = true;
+      cliOptions.execute = passedArgument;
+      arbitaryCliArgumets.pop();
     }
   });
-  if (Object.keys(cliOptions2).length === 0) {
-    return void 0;
+  if (Object.keys(cliOptions).length === 0) {
+    return { cliOptions: void 0, arbitaryCliArgumets };
   }
-  return cliOptions2;
+  return { cliOptions, arbitaryCliArgumets };
+}
+function extractScriptRelatedCliOptions(passedArguments) {
+  const { cliOptions: cliOptionsPassedThroughScript } = extractCliOptions(passedArguments);
+  const scriptRelatedCliOptions = { ...cliOptionsPassedThroughScript };
+  delete scriptRelatedCliOptions?.configFileLocation;
+  const scriptName = identifyScript(passedArguments);
+  const configurationFromCliOption = {
+    [scriptName]: { ...scriptRelatedCliOptions }
+  };
+  return configurationFromCliOption;
 }
-const cliOptions = extractCliOptions();
-const scriptRelatedCliOptions = { ...cliOptions };
-delete scriptRelatedCliOptions?.configFileLocation;
-function executeConfigFile() {
-  const determinedConfigFileLocation = cliOptions?.configFileLocation ?? availableFile(validConfigFilesOrder, process.cwd());
+function executeConfigFile(passedArguments) {
+  const { cliOptions } = extractCliOptions(passedArguments);
+  const determinedConfigFileLocation = cliOptions?.configFileLocation ?? resolveConfigFile(validConfigFilesOrder, process.cwd());
   if (!determinedConfigFileLocation) {
-    console.log("No config file found");
+    console.error("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);
+  const config$1 = moduleFromConfigFile?.default ?? moduleFromConfigFile;
+  const parsedConfig = config.configSchema.safeParse(config$1);
   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
+  function resolveConfigFile(fileOrder, dir) {
+    for (const file of fileOrder) {
+      const fullPath = path.join(dir, file);
+      if (node_fs.existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+    return null;
   }
-};
-const finalConfig = {
-  ...configurationFromConfigFile,
-  scripts: { ...mergedScriptDetails }
-};
+}
+function finalizedConfigFromAllSources(passedArguments) {
+  const configFromConfigFile = executeConfigFile(passedArguments);
+  const scriptRelatedCliOptions = extractScriptRelatedCliOptions(passedArguments);
+  const scriptsDetailsFromConfigFile = configFromConfigFile && configFromConfigFile.scripts || {};
+  const scriptName = identifyScript(passedArguments);
+  const mergedScriptDetails = {
+    ...scriptsDetailsFromConfigFile,
+    [scriptName]: {
+      ...scriptsDetailsFromConfigFile[scriptName] || {},
+      ...scriptRelatedCliOptions
+    }
+  };
+  const finalConfig = {
+    ...configFromConfigFile,
+    scripts: { ...mergedScriptDetails }
+  };
+  return finalConfig;
+}
 
-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());
+const passedArguments = node_process.argv.slice(2);
+(() => {
+  const scriptName = identifyScript(passedArguments);
+  const finalConfig = finalizedConfigFromAllSources(passedArguments);
+  const { arbitaryCliArgumets } = extractCliOptions(passedArguments);
+  const envFileToLoad = availableEnvFile({
+    scriptName,
+    scanningDir: finalConfig.envDir
   });
-  process.on("exit", (code, signal) => {
-    console.log(`Process exited with code ${code}, signal ${signal}`);
+  if (!envFileToLoad) {
+    console.error("No env file is provided");
+  }
+  dotenv.config({
+    path: path.join(node_process.cwd(), envFileToLoad || ""),
+    quiet: true
   });
-}
+  if (finalConfig?.scripts?.[scriptName]?.execute) {
+    const executableCommand = finalConfig.scripts[scriptName].execute.split(",");
+    const executable = executableCommand[0];
+    const commandArgs = executableCommand.slice(1).concat(arbitaryCliArgumets);
+    const executingProcess = node_child_process.spawn(`${executable} ${commandArgs.join(" ")}`, {
+      stdio: "inherit",
+      // Use shell mode unless explicitly disabled in config
+      shell: finalConfig.scripts[scriptName].shell ?? true
+    });
+    executingProcess.on("exit", (code, signal) => {
+      console.log(`Process exited with code ${code}, signal ${signal}`);
+    });
+  }
+})();
+
+exports.passedArguments = passedArguments;

package/dist/exports/{config.d.cts → config.d.ts}

@@ -1,10 +1,11 @@
+import { CommonSpawnOptions } from 'node:child_process';
 import { z } from 'zod';
 
 type ScriptDetails = {
     envFile?: string;
     execute: string;
     envDir?: string;
-};
+} & Partial<Pick<CommonSpawnOptions, "shell">>;
 type Scripts = {
     dev?: ScriptDetails;
     build?: ScriptDetails;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforge-cli",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "description": "A cli tool to leverage env related headache",
   "lint-staged": {
     "src/**/*.ts": "pnpm format"
@@ -9,20 +9,23 @@
     "prebuild": "rimraf ./dist",
     "build": "pkgroll",
     "format": "prettier --write src/**/*.ts",
-    "test": "tsx --test",
+    "test:unit": "vitest",
+    "test:unit:coverage": "vitest --coverage.enabled",
     "pre-commit": "lint-staged"
   },
   "bin": {
     "tf": "dist/bin/index.js"
   },
+  "types": "./dist/**/*.d.ts",
   "exports": {
     "./config": {
+      "types": {
+        "default": "./dist/exports/config.d.ts"
+      },
       "require": {
-        "types": "./dist/exports/config.d.cts",
         "default": "./dist/exports/config.cjs"
       },
       "import": {
-        "types": "./dist/exports/config.d.mts",
         "default": "./dist/exports/config.mjs"
       }
     }
@@ -52,12 +55,16 @@
   "dependencies": {
     "dotenv": "^17.2.3",
     "jiti": "^2.6.1",
+    "vite-tsconfig-paths": "^6.0.4",
+    "vitest": "^4.0.17",
     "zod": "^4.2.1"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "4.0.17",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
+    "memfs": "^4.51.1",
     "pkgroll": "^2.21.4",
     "prettier": "^3.7.4",
     "rimraf": "^6.1.2",

package/dist/exports/config.d.mts

@@ -1,60 +0,0 @@
-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 };