@ts-for-gir/cli 4.0.0-beta.9 → 4.0.0-rc.10

package/src/commands/list.ts

@@ -2,101 +2,82 @@
  * Everything you need for the `ts-for-gir list` command is located here
  */
 
-import { Argv, BuilderCallback } from 'yargs'
-import { ModuleLoader } from '../module-loader.js'
-import { Config } from '../config.js'
-import { Logger, ERROR_NO_MODULES_FOUND, ResolveType } from '@ts-for-gir/lib'
+import type { ConfigFlags } from "@ts-for-gir/lib";
+import { APP_NAME, ERROR_NO_MODULES_FOUND, Logger, NSRegistry } from "@ts-for-gir/lib";
+import { getOptionsGeneration, listOptions, load } from "../config.ts";
+import { ModuleLoader } from "../module-loader.ts";
+import type { ListCommandArgs } from "../types/index.ts";
+import { createBuilder } from "./command-builder.ts";
 
-import type { ConfigFlags } from '@ts-for-gir/lib'
+const command = "list [modules..]";
 
-const command = 'list [modules..]'
+const description = "Lists all available GIR modules";
 
-const description = 'Lists all available GIR modules'
+const logger = new Logger(true, "ListCommand");
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const builder: BuilderCallback<any, ConfigFlags> = (yargs: Argv<any>) => {
-    const optionNames = Object.keys(Config.listOptions)
-    for (const optionName of optionNames) {
-        yargs = yargs.option(optionName, Config.listOptions[optionName])
-    }
-    return yargs.example(examples) as Argv<ConfigFlags>
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const handler = async (args: ConfigFlags) => {
-    const config = await Config.load(args)
-    const generateConfig = Config.getOptionsGeneration(config)
-    const moduleLoader = new ModuleLoader(generateConfig)
-    const { grouped, failed } = await moduleLoader.getModules(config.modules, config.ignore)
-    const moduleGroups = Object.values(grouped)
-    if (Object.keys(grouped).length === 0) {
-        return Logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories))
-    }
-
-    const conflictModules = moduleGroups.filter((moduleGroup) => moduleGroup.hasConflict)
-
-    const byHandModules = moduleGroups.filter(
-        (moduleGroup) => moduleGroup.modules[0].resolvedBy === ResolveType.BY_HAND,
-    )
-
-    const depModules = moduleGroups.filter(
-        (moduleGroup) => moduleGroup.modules[0].resolvedBy === ResolveType.DEPENDENCE,
-    )
-
-    Logger.info('\nSearch for gir files in:')
-    for (const dir of config.girDirectories) {
-        Logger.white(`- ${dir}`)
-    }
-
-    Logger.info('\nSelected Modules:')
-    for (const moduleGroup of byHandModules) {
-        for (const depModule of moduleGroup.modules) {
-            Logger.white(`- ${depModule.packageName}`)
-            Logger.gray(`  - ${depModule.path}`)
-        }
-    }
-
-    if (depModules.length > 0) {
-        Logger.yellow('\nDependencies:')
-        for (const moduleGroup of depModules) {
-            for (const depModule of moduleGroup.modules) {
-                Logger.white(`- ${depModule.packageName}`)
-                Logger.gray(`- ${depModule.path}`)
-            }
-        }
-    }
-
-    if (conflictModules.length > 0) {
-        Logger.danger('\nConflicts:')
-        for (const moduleGroup of conflictModules) {
-            Logger.white(`- ${moduleGroup.namespace}`)
-            for (const conflictModule of moduleGroup.modules) {
-                Logger.white(`  - ${conflictModule.packageName}`)
-                Logger.gray(`  - ${conflictModule.path}`)
-            }
-        }
-    }
+const examples: ReadonlyArray<[string, string?]> = [
+	[`${APP_NAME} list -g ./vala-girs/gir-1.0`, "Lists all available GIR modules in ./vala-girs/gir-1.0"],
+	[
+		`${APP_NAME} list --ignore=Gtk-3.0 xrandr-1.3`,
+		"Lists all available GIR modules in /usr/share/gir-1.0 but not Gtk-3.0 and xrandr-1.3",
+	],
+];
 
-    if (failed.length > 0) {
-        Logger.danger('\nDependencies not found:')
-        for (const fail of failed) {
-            Logger.white(`- ${fail}`)
-        }
-    }
-}
+const builder = createBuilder<ListCommandArgs>(listOptions, examples);
 
-const examples: ReadonlyArray<[string, string?]> = [
-    [`${Config.appName} list -g ./vala-girs/gir-1.0`, `Lists all available GIR modules in ./vala-girs/gir-1.0`],
-    [
-        `${Config.appName} list --ignore=Gtk-3.0 xrandr-1.3`,
-        'Lists all available GIR modules in /usr/share/gir-1.0 but not Gtk-3.0 and xrandr-1.3',
-    ],
-]
+const handler = async (args: ConfigFlags) => {
+	const config = await load(args);
+	const generateConfig = getOptionsGeneration(config);
+	const registry = new NSRegistry();
+	const moduleLoader = new ModuleLoader(generateConfig, registry);
+	const { grouped, failed } = await moduleLoader.getModules(config.modules, config.ignore);
+	const moduleGroups = Object.values(grouped);
+
+	if (Object.keys(grouped).length === 0) {
+		return logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories));
+	}
+
+	const conflictModules = moduleGroups.filter((moduleGroup) => moduleGroup.hasConflict);
+	const allModules = moduleGroups.filter((moduleGroup) => !moduleGroup.hasConflict);
+
+	logger.info("\nSearch for gir files in:");
+	for (const dir of config.girDirectories) {
+		logger.white(`- ${dir}`);
+	}
+
+	// Show all available modules
+	logger.info("\nAvailable Modules:");
+	for (const moduleGroup of allModules) {
+		for (const module of moduleGroup.modules) {
+			logger.white(`- ${module.packageName}`);
+			logger.gray(`  - ${module.path}`);
+		}
+	}
+
+	// Only show sections if there is actual content
+	if (conflictModules.length > 0) {
+		logger.danger("\nConflicts:");
+		for (const moduleGroup of conflictModules) {
+			logger.white(`- ${moduleGroup.namespace}`);
+			for (const conflictModule of moduleGroup.modules) {
+				logger.white(`  - ${conflictModule.packageName}`);
+				logger.gray(`  - ${conflictModule.path}`);
+			}
+		}
+	}
+
+	if (failed.length > 0) {
+		logger.danger("\nDependencies not found:");
+		for (const fail of failed) {
+			logger.white(`- ${fail}`);
+		}
+	}
+};
 
 export const list = {
-    command,
-    description,
-    builder,
-    handler,
-    examples,
-}
+	command,
+	description,
+	builder,
+	handler,
+	examples,
+};

package/src/commands/run-generation-command.ts

@@ -0,0 +1,75 @@
+import type { GeneratorType } from "@ts-for-gir/generator-base";
+import {
+	type ConfigFlags,
+	ERROR_NO_MODULES_FOUND,
+	type GirModule,
+	Logger,
+	NSRegistry,
+	ReporterService,
+	ResolveType,
+} from "@ts-for-gir/lib";
+import { getOptionsGeneration, load } from "../config.ts";
+import { GenerationHandler } from "../generation-handler.ts";
+import { ModuleLoader } from "../module-loader.ts";
+
+interface GenerationCommandOptions {
+	generatorType: GeneratorType;
+	loggerName: string;
+	configureRegistry?: (registry: NSRegistry) => void;
+}
+
+export async function runGenerationCommand(args: ConfigFlags, options: GenerationCommandOptions): Promise<void> {
+	const config = await load(args);
+	const generateConfig = getOptionsGeneration(config);
+	const logger = new Logger(true, options.loggerName);
+	const registry = new NSRegistry();
+
+	options.configureRegistry?.(registry);
+
+	const moduleLoader = new ModuleLoader(generateConfig, registry);
+
+	let tsForGir: GenerationHandler | null = null;
+
+	try {
+		const { keep } = await moduleLoader.getModulesResolved(
+			config.modules,
+			config.ignore || [],
+			config.ignoreVersionConflicts,
+		);
+
+		if (keep.length === 0) {
+			logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories));
+			return;
+		}
+
+		tsForGir = new GenerationHandler(generateConfig, options.generatorType, registry);
+
+		moduleLoader.parse(keep);
+
+		// In external-deps mode, only generate the user-requested module(s). Transitively-loaded
+		// deps stay in the registry for type resolution but must not produce their own output.
+		const toGenerate = generateConfig.externalDeps ? keep.filter((m) => m.resolvedBy === ResolveType.BY_HAND) : keep;
+
+		const girModules = Array.from(toGenerate).map((girModuleResolvedBy) => girModuleResolvedBy.module as GirModule);
+
+		await tsForGir.start(girModules);
+	} catch (error) {
+		if (generateConfig.reporter && tsForGir) {
+			const service = ReporterService.getInstance();
+
+			if (tsForGir.log) {
+				tsForGir.log.reportGenerationFailure(
+					"Main",
+					error instanceof Error ? error : new Error(String(error)),
+					"Generation failed",
+				);
+			}
+
+			const report = service.generateComprehensiveReport();
+			service.printComprehensiveSummary(report);
+			await service.saveComprehensiveReport(undefined, report);
+		}
+
+		throw error;
+	}
+}

package/src/commands/self-update.ts

@@ -0,0 +1,142 @@
+/**
+ * Everything you need for the `ts-for-gir self-update` command is located here
+ */
+
+import { chmodSync, existsSync, renameSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { APP_NAME, APP_VERSION } from "@ts-for-gir/lib";
+
+import type { SelfUpdateCommandArgs } from "../types/index.ts";
+
+const REPO = "gjsify/ts-for-gir";
+const GITHUB_API = "https://api.github.com";
+const GJS_ASSET_NAME = "ts-for-gir-gjs";
+
+function getCurrentBinaryPath(): string | null {
+	const p = process.argv[1] ?? null;
+	if (!p) return null;
+	// Refuse to update in dev mode (source file or node_modules path)
+	if (p.endsWith(".ts") || p.includes("node_modules")) return null;
+	return p;
+}
+
+async function fetchJson(url: string): Promise<unknown> {
+	const headers: Record<string, string> = {
+		Accept: "application/vnd.github.v3+json",
+		"User-Agent": `ts-for-gir/${APP_VERSION}`,
+	};
+	const token = process.env.GITHUB_TOKEN;
+	if (token) headers.Authorization = `token ${token}`;
+
+	const response = await fetch(url, { headers });
+	if (!response.ok) {
+		throw new Error(`HTTP ${response.status} from ${url}`);
+	}
+	return response.json();
+}
+
+async function downloadBinary(url: string, destPath: string): Promise<void> {
+	const response = await fetch(url, {
+		headers: { "User-Agent": `ts-for-gir/${APP_VERSION}` },
+	});
+	if (!response.ok) {
+		throw new Error(`HTTP ${response.status} downloading binary`);
+	}
+	const buffer = await response.arrayBuffer();
+	const tmpPath = join(tmpdir(), `ts-for-gir-update-${Date.now()}`);
+	writeFileSync(tmpPath, Buffer.from(buffer));
+	chmodSync(tmpPath, 0o755);
+	renameSync(tmpPath, destPath); // atomic on POSIX
+}
+
+const command = "self-update";
+const description = "Update ts-for-gir to the latest version from GitHub releases";
+const examples: ReadonlyArray<[string, string?]> = [
+	[`${APP_NAME} self-update`, "Check for updates and install the latest version"],
+	[`${APP_NAME} self-update --check`, "Only check for a newer version, do not install"],
+	[`${APP_NAME} self-update --force`, "Force reinstall even if already on the latest version"],
+];
+
+const builder = (yargs: import("yargs").Argv) =>
+	yargs
+		.option("check", {
+			description: "Only check for a newer version, do not install",
+			type: "boolean",
+			default: false,
+		})
+		.option("force", {
+			description: "Force reinstall even if already on the latest version",
+			type: "boolean",
+			default: false,
+		})
+		.example(examples as [string, string?][]);
+
+const handler = async (args: SelfUpdateCommandArgs): Promise<void> => {
+	console.log(`Checking for updates... (current: v${APP_VERSION})`);
+
+	let release: Record<string, unknown>;
+	try {
+		release = (await fetchJson(`${GITHUB_API}/repos/${REPO}/releases/latest`)) as Record<string, unknown>;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`Failed to fetch release information: ${msg}\n`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const latestVersion = (release.tag_name as string).replace(/^v/, "");
+
+	if (latestVersion === APP_VERSION && !args.force) {
+		console.log(`Already up to date (v${APP_VERSION})`);
+		return;
+	}
+
+	if (args.check) {
+		console.log(`New version available: v${latestVersion} (current: v${APP_VERSION})`);
+		console.log(`Run \`${APP_NAME} self-update\` to install it.`);
+		return;
+	}
+
+	console.log(`Updating to v${latestVersion}...`);
+
+	const assets = release.assets as Array<Record<string, string>>;
+	const asset = assets.find((a) => a.name === GJS_ASSET_NAME);
+	if (!asset) {
+		process.stderr.write(
+			`No GJS binary found in release ${release.tag_name}.\n` +
+				"self-update requires the GJS bundle to be installed via install.js.\n" +
+				"For npm installations use: npm update -g @ts-for-gir/cli\n",
+		);
+		process.exitCode = 1;
+		return;
+	}
+
+	const currentPath = getCurrentBinaryPath();
+	if (!currentPath || !existsSync(currentPath)) {
+		process.stderr.write(
+			"Cannot determine current binary path for update.\n" +
+				"self-update only works when running the installed GJS binary.\n",
+		);
+		process.exitCode = 1;
+		return;
+	}
+
+	try {
+		await downloadBinary(asset.browser_download_url, currentPath);
+		console.log(`Successfully updated to v${latestVersion}`);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`Update failed: ${msg}\n`);
+		process.exitCode = 1;
+	}
+};
+
+export const selfUpdate = {
+	command,
+	description,
+	builder,
+	handler,
+	examples,
+};

package/src/config/config-loader.ts

@@ -0,0 +1,238 @@
+/**
+ * Config loader functionality for ts-for-gir
+ */
+
+import { dirname, resolve } from "node:path";
+import type { ConfigFlags, OptionsGeneration, UserConfig, UserConfigLoadResult } from "@ts-for-gir/lib";
+import { APP_NAME, isEqual } from "@ts-for-gir/lib";
+import { type Options as ConfigSearchOptions, cosmiconfig } from "cosmiconfig";
+import { setConfigFilePath } from "./config-writer.ts";
+import { defaults } from "./defaults.ts";
+import { docOptions, options } from "./options.ts";
+
+/**
+ * The user can create a `.ts-for-girrc` file for his default configs,
+ * this method load this config file an returns the user configuration
+ * @param configName If the user uses a custom config file name
+ */
+export async function loadConfigFile(configName?: string): Promise<UserConfigLoadResult | null> {
+	const configSearchOptions: Partial<ConfigSearchOptions> = {
+		loaders: {
+			// ESM loader
+			".js": async (filepath) => {
+				const file = await import(filepath);
+
+				// Files with `exports.default = { ... }`
+				if (file?.default?.default) {
+					return file.default.default as Partial<UserConfig>;
+				}
+				// Files with `export default { ... }`
+				if (file?.default) {
+					return file.default as Partial<UserConfig>;
+				}
+				// Files with `export { ... }`
+				return file as Partial<UserConfig>;
+			},
+		},
+	};
+
+	if (configName) {
+		configSearchOptions.searchPlaces = [configName];
+	}
+
+	const configFile: UserConfigLoadResult | null = await cosmiconfig(APP_NAME, configSearchOptions).search();
+
+	if (configFile?.filepath) {
+		setConfigFilePath(configFile.filepath);
+	}
+
+	return configFile;
+}
+
+/**
+ * Convert UserConfig to OptionsGeneration
+ */
+export function getOptionsGeneration(config: UserConfig): OptionsGeneration {
+	const generateConfig: OptionsGeneration = {
+		...config,
+	};
+	return generateConfig;
+}
+
+/**
+ * Parse `Namespace=npm-package` strings (from repeatable `--external-package` flag) into a
+ * map. Silently drops entries that don't contain `=`. Empty input returns undefined so the
+ * field stays absent in the merged config (rather than `{}`, which would shadow rc values).
+ */
+function parseExternalPackagePairs(pairs: string[] | undefined): Record<string, string> | undefined {
+	if (!pairs || pairs.length === 0) return undefined;
+	const map: Record<string, string> = {};
+	for (const pair of pairs) {
+		const eq = pair.indexOf("=");
+		if (eq < 1) continue;
+		const ns = pair.slice(0, eq).trim();
+		const pkg = pair.slice(eq + 1).trim();
+		if (ns && pkg) map[ns] = pkg;
+	}
+	return Object.keys(map).length > 0 ? map : undefined;
+}
+
+/**
+ * Validate the configuration
+ */
+export function validate(config: UserConfig): UserConfig {
+	return config;
+}
+
+/**
+ * Merge a single config value from file config to user config
+ * @param userConfig The user config object to update
+ * @param configFileData The config file data to merge from
+ * @param key The config key to merge
+ * @param optionDefault The default value from options
+ * @param validator Optional validation function
+ */
+const isBoolean = (v: unknown) => typeof v === "boolean";
+
+function mergeConfigValue<K extends keyof UserConfig>(
+	userConfig: UserConfig,
+	configFileData: Partial<UserConfig>,
+	key: K,
+	optionDefault: unknown,
+	validator?: (value: unknown) => boolean,
+): void {
+	const fileValue = configFileData[key];
+	const userValue = userConfig[key];
+
+	// Skip if no file value
+	if (fileValue === undefined) return;
+
+	// Apply validator if provided
+	if (validator && !validator(fileValue)) return;
+
+	// Check if user value is default
+	const isDefault =
+		userValue === optionDefault ||
+		(Array.isArray(userValue) && Array.isArray(optionDefault) && isEqual(userValue, optionDefault));
+
+	if (isDefault) {
+		(userConfig[key] as UserConfig[K]) = fileValue as UserConfig[K];
+	}
+}
+
+/**
+ * Loads the values of the config file and concatenate them with passed cli flags / arguments.
+ * The values from config file are preferred if the cli flag value is the default (and so not set / overwritten)
+ * @param cliOptions CLI options passed by the user
+ */
+export async function load(cliOptions: ConfigFlags): Promise<UserConfig> {
+	const configFile = await loadConfigFile(cliOptions.configName);
+	const configFileData = configFile?.config || {};
+
+	// `--external-package GLib=@girs/glib-2.0` arrives as a string[]; collapse to Record.
+	// Drop the raw array so it doesn't pollute the merged UserConfig surface.
+	const externalPackagesFromCli = parseExternalPackagePairs(
+		(cliOptions as { externalPackage?: string[] }).externalPackage,
+	);
+	const { externalPackage: _externalPackage, ...cliOptionsClean } = cliOptions as ConfigFlags & {
+		externalPackage?: string[];
+	};
+
+	const userConfig: UserConfig = {
+		...cliOptionsClean,
+	};
+	if (externalPackagesFromCli) {
+		userConfig.externalPackages = externalPackagesFromCli;
+	}
+
+	if (configFileData) {
+		// Boolean options — config file overrides CLI defaults
+		const booleanKeys: Array<[keyof UserConfig, unknown]> = [
+			["verbose", options.verbose.default],
+			["ignoreVersionConflicts", options.ignoreVersionConflicts.default],
+			["print", options.print.default],
+			["noNamespace", options.noNamespace.default],
+			["noComments", options.noComments.default],
+			["promisify", options.promisify.default],
+			["workspace", options.workspace.default],
+			["onlyVersionPrefix", options.onlyVersionPrefix.default],
+			["noPrettyPrint", options.noPrettyPrint.default],
+			["noAdvancedVariants", options.noAdvancedVariants.default],
+			["package", options.package.default],
+			["reporter", options.reporter.default],
+			["externalDeps", options.externalDeps.default],
+			["allowMissingDeps", options.allowMissingDeps.default],
+			["combined", docOptions.combined.default],
+			["merge", docOptions.merge.default],
+		];
+		for (const [key, defaultVal] of booleanKeys) {
+			mergeConfigValue(userConfig, configFileData, key, defaultVal, isBoolean);
+		}
+
+		// String options — config file overrides CLI defaults
+		const stringKeys: Array<[keyof UserConfig, unknown]> = [
+			["npmScope", options.npmScope.default],
+			["reporterOutput", options.reporterOutput.default],
+			["depVersionFormat", undefined],
+			["theme", docOptions.theme.default],
+			["sourceLinkTemplate", undefined],
+			["readme", undefined],
+			["jsonDir", undefined],
+		];
+		for (const [key, defaultVal] of stringKeys) {
+			mergeConfigValue(userConfig, configFileData, key, defaultVal);
+		}
+
+		// Array options — config file overrides CLI defaults
+		const arrayKeys: Array<[keyof UserConfig, unknown]> = [
+			["ignore", options.ignore.default],
+			["modules", options.modules.default],
+		];
+		for (const [key, defaultVal] of arrayKeys) {
+			mergeConfigValue(userConfig, configFileData, key, defaultVal);
+		}
+
+		// girDirectories: rc-file entries are prepended to the current dirs (CLI-provided or
+		// system defaults) rather than replacing them. This lets projects add local GIR dirs
+		// (e.g. a Vala build output) without having to enumerate all system paths in the rc.
+		// To use ONLY the specified dirs (no system fallback), pass --girDirectories on the CLI.
+		if (configFileData.girDirectories?.length) {
+			const current = userConfig.girDirectories as string[];
+			const toAdd = (configFileData.girDirectories as string[]).filter((d) => !current.includes(d));
+			if (toAdd.length > 0) {
+				userConfig.girDirectories = [...toAdd, ...current];
+			}
+		}
+
+		// Special handling for root
+		if (userConfig.root === options.root.default && (configFileData.root || configFile?.filepath)) {
+			userConfig.root =
+				configFileData.root || (configFile?.filepath ? dirname(configFile.filepath) : (options.root.default as string));
+		}
+
+		// Special handling for outdir (override with config file value if still at a default)
+		const isDefaultOutdir = userConfig.outdir === options.outdir.default || userConfig.outdir === defaults.docOutdir;
+		if (isDefaultOutdir && configFileData.outdir) {
+			userConfig.outdir = userConfig.print ? null : configFileData.outdir;
+		}
+
+		// externalPackages is a Record<string, string> in rc files; CLI overrides take precedence.
+		if (!externalPackagesFromCli && configFileData.externalPackages) {
+			userConfig.externalPackages = configFileData.externalPackages;
+		}
+	}
+
+	// Make paths absolute relative to root
+	const resolveToRoot = (path: string) => (path.startsWith("/") ? path : resolve(userConfig.root, path));
+
+	if (userConfig.outdir) {
+		userConfig.outdir = resolveToRoot(userConfig.outdir);
+	}
+	if (userConfig.jsonDir) {
+		userConfig.jsonDir = resolveToRoot(userConfig.jsonDir);
+	}
+	if (userConfig.girDirectories) {
+		userConfig.girDirectories = userConfig.girDirectories.map(resolveToRoot);
+	}
+	return validate(userConfig);
+}

package/src/config/config-writer.ts

@@ -0,0 +1,52 @@
+/**
+ * Config writer functionality for ts-for-gir
+ */
+
+import { writeFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+import type { UserConfig } from "@ts-for-gir/lib";
+import { ERROR_CONFIG_EXTENSION_UNSUPPORTED, Logger, merge } from "@ts-for-gir/lib";
+import { loadConfigFile } from "./config-loader.ts";
+import { defaults } from "./defaults.ts";
+
+const logger = new Logger(false, "ConfigWriter");
+
+export let configFilePath = join(process.cwd(), defaults.configName);
+
+/**
+ * Update the config file path when a config is loaded
+ */
+export function setConfigFilePath(path: string): void {
+	configFilePath = path;
+}
+
+/**
+ * Overwrites values in the user config file
+ * @param configsToAdd Configuration values to add/update
+ * @param configName Optional custom config file name
+ */
+export async function addToConfig(configsToAdd: Partial<UserConfig>, configName?: string): Promise<void> {
+	const userConfig = await loadConfigFile(configName);
+	const path = userConfig?.filepath || configFilePath;
+	const configToStore = {};
+	merge(configToStore, userConfig?.config || {}, configsToAdd);
+
+	const fileExtension = extname(path);
+	let writeConfigString = "";
+
+	switch (fileExtension) {
+		case ".js":
+			writeConfigString = `export default ${JSON.stringify(configToStore, null, 4)}`;
+			break;
+		case ".json":
+			writeConfigString = `${JSON.stringify(configToStore, null, 4)}`;
+			break;
+		default:
+			logger.error(ERROR_CONFIG_EXTENSION_UNSUPPORTED);
+			break;
+	}
+
+	if (writeConfigString && path) {
+		return writeFile(path, writeConfigString);
+	}
+}