@alint-js/config 0.0.4

package/dist/index.d.mts

@@ -0,0 +1,26 @@
+import { AlintConfig, AlintConfig as AlintConfig$1, ModelSize, ProviderDefinition, ProviderType, RunnerConfig, SetupConfig, SetupConfig as SetupConfig$1, SetupModelDefinition } from "@alint-js/core";
+
+//#region src/load-config.d.ts
+declare function loadAlintConfig(cwd: string, configFile?: string): Promise<AlintConfig$1>;
+//#endregion
+//#region src/paths.d.ts
+interface GlobalSetupConfigPathOptions {
+  isMacOS?: boolean;
+  xdgConfig?: string;
+}
+declare function getGlobalSetupConfigPath(env?: NodeJS.ProcessEnv, options?: GlobalSetupConfigPathOptions): string;
+declare function getProjectSetupConfigPath(cwd: string): string;
+//#endregion
+//#region src/setup-load.d.ts
+declare const emptySetupConfig: SetupConfig$1;
+declare function loadSetupConfig(filePath: string): Promise<SetupConfig$1>;
+declare function mergeSetupConfigs(...configs: SetupConfig$1[]): SetupConfig$1;
+//#endregion
+//#region src/setup-toml.d.ts
+declare function parseSetupConfigToml(toml: string): SetupConfig$1;
+declare function stringifySetupConfigToml(config: SetupConfig$1): string;
+//#endregion
+//#region src/setup-write.d.ts
+declare function writeSetupConfig(filePath: string, config: SetupConfig$1): Promise<void>;
+//#endregion
+export { type AlintConfig, type GlobalSetupConfigPathOptions, type ModelSize, type ProviderDefinition, type ProviderType, type RunnerConfig, type SetupConfig, type SetupModelDefinition, emptySetupConfig, getGlobalSetupConfigPath, getProjectSetupConfigPath, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, parseSetupConfigToml, stringifySetupConfigToml, writeSetupConfig };

package/dist/index.mjs

@@ -0,0 +1,282 @@
+import { loadConfig } from "c12";
+import process from "node:process";
+import { homedir } from "node:os";
+import { dirname, join } from "pathe";
+import { xdgConfig } from "xdg-basedir";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { parse, stringify } from "smol-toml";
+//#region src/load-config.ts
+async function loadAlintConfig(cwd, configFile) {
+	return (await loadConfig({
+		configFile,
+		cwd,
+		defaults: {
+			plugins: [],
+			rules: {}
+		},
+		dotenv: true,
+		name: "alint"
+	})).config;
+}
+//#endregion
+//#region src/paths.ts
+function getGlobalSetupConfigPath(env = process.env, options = {}) {
+	return join(env.XDG_CONFIG_HOME ?? resolveDefaultConfigHome(options), "alint", "config.toml");
+}
+function getProjectSetupConfigPath(cwd) {
+	return join(cwd, ".alint", "config.toml");
+}
+function resolveDefaultConfigHome(options) {
+	if (options.isMacOS ?? process.platform === "darwin") return join(homedir(), ".config");
+	return options.xdgConfig ?? xdgConfig ?? join(homedir(), ".config");
+}
+//#endregion
+//#region src/setup-toml.ts
+const modelSizes = /* @__PURE__ */ new Set([
+	"large",
+	"medium",
+	"small"
+]);
+function parseSetupConfigToml(toml) {
+	const rawConfig = parse(toml);
+	if (rawConfig.version !== 1) throw new Error("Invalid setup config: version must be 1.");
+	if (!Array.isArray(rawConfig.providers)) throw new TypeError("Invalid setup config: providers must be an array.");
+	const parsedConfig = {
+		providers: rawConfig.providers.map((provider) => parseProvider(provider)),
+		version: 1
+	};
+	if (rawConfig.runner !== void 0) parsedConfig.runner = parseRunner(rawConfig.runner);
+	return parsedConfig;
+}
+function stringifySetupConfigToml(config) {
+	const stringifiableConfig = {
+		providers: config.providers.map(toTomlProvider),
+		version: config.version
+	};
+	if (config.runner !== void 0) stringifiableConfig.runner = toTomlRunner(config.runner);
+	return stringify(stringifiableConfig);
+}
+function isModelSize(value) {
+	return typeof value === "string" && modelSizes.has(value);
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseModel(providerId, model) {
+	const id = readNonEmptyString(model.id, `provider "${providerId}" model id`);
+	const parsedModel = { id };
+	if (model.name !== void 0) parsedModel.name = readString(model.name, `model "${id}" name`);
+	if (model.aliases !== void 0) parsedModel.aliases = readStringArray(model.aliases, `model "${id}" aliases`);
+	if (model.capabilities !== void 0) parsedModel.capabilities = readStringArray(model.capabilities, `model "${id}" capabilities`);
+	if (model.size !== void 0) {
+		if (!isModelSize(model.size)) throw new Error(`Invalid model "${id}": size must be "small", "medium", or "large".`);
+		parsedModel.size = model.size;
+	}
+	if (model.context_window !== void 0) parsedModel.contextWindow = readFiniteNumber(model.context_window, `model "${id}" context_window`);
+	if (model.default_params !== void 0) parsedModel.defaultParams = readRecord(model.default_params, `model "${id}" default_params`);
+	return parsedModel;
+}
+function parsePositiveInteger(value, label) {
+	if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) throw new TypeError(`Invalid ${label}: must be a positive integer.`);
+	return value;
+}
+function parseProvider(provider) {
+	const id = readNonEmptyString(provider.id, "provider id");
+	if (provider.type !== "openai-compatible") throw new Error(`Invalid provider "${id}": type must be "openai-compatible".`);
+	const endpoint = readNonEmptyString(provider.endpoint, `provider "${id}" endpoint`);
+	if (!Array.isArray(provider.models)) throw new TypeError(`Invalid provider "${id}": models must be an array.`);
+	const parsedProvider = {
+		endpoint,
+		id,
+		models: provider.models.map((model) => parseModel(id, model)),
+		type: provider.type
+	};
+	if (provider.headers !== void 0) parsedProvider.headers = readStringMap(provider.headers, `provider "${id}" headers`);
+	return parsedProvider;
+}
+function parseRunner(runner) {
+	const parsedRunner = {};
+	if (runner.cache !== void 0) parsedRunner.cache = parseRunnerCache(runner.cache);
+	if (runner.file_concurrency !== void 0) parsedRunner.fileConcurrency = parsePositiveInteger(runner.file_concurrency, "runner file_concurrency");
+	if (runner.rule_concurrency !== void 0) parsedRunner.ruleConcurrency = parsePositiveInteger(runner.rule_concurrency, "runner rule_concurrency");
+	if (runner.timeout_ms !== void 0) parsedRunner.timeoutMs = parsePositiveInteger(runner.timeout_ms, "runner timeout_ms");
+	return parsedRunner;
+}
+function parseRunnerCache(cache) {
+	if (typeof cache === "boolean") return cache;
+	if (!isPlainObject(cache)) throw new TypeError("Invalid runner cache: must be a boolean or table.");
+	const tomlCache = cache;
+	const parsedCache = {};
+	if (tomlCache.enabled !== void 0) {
+		if (typeof tomlCache.enabled !== "boolean") throw new TypeError("Invalid runner cache enabled: must be a boolean.");
+		parsedCache.enabled = tomlCache.enabled;
+	}
+	if (tomlCache.location !== void 0) parsedCache.location = readNonEmptyString(tomlCache.location, "runner cache location");
+	return parsedCache;
+}
+function readFiniteNumber(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`Invalid ${label}: must be a finite number.`);
+	return value;
+}
+function readNonEmptyString(value, label) {
+	const stringValue = readString(value, label);
+	if (stringValue.length === 0) throw new Error(`Invalid ${label}: must be a non-empty string.`);
+	return stringValue;
+}
+function readRecord(value, label) {
+	if (!isPlainObject(value)) throw new Error(`Invalid ${label}: must be a table.`);
+	return value;
+}
+function readString(value, label) {
+	if (typeof value !== "string") throw new TypeError(`Invalid ${label}: must be a string.`);
+	return value;
+}
+function readStringArray(value, label) {
+	if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) throw new Error(`Invalid ${label}: must be an array of strings.`);
+	return value;
+}
+function readStringMap(value, label) {
+	const record = readRecord(value, label);
+	if (!Object.values(record).every((item) => typeof item === "string")) throw new Error(`Invalid ${label}: must be a string map.`);
+	return record;
+}
+function toTomlModel(model) {
+	const tomlModel = { id: model.id };
+	if (model.name !== void 0) tomlModel.name = model.name;
+	if (model.aliases !== void 0) tomlModel.aliases = model.aliases;
+	if (model.capabilities !== void 0) tomlModel.capabilities = model.capabilities;
+	if (model.size !== void 0) tomlModel.size = model.size;
+	if (model.contextWindow !== void 0) tomlModel.context_window = model.contextWindow;
+	if (model.defaultParams !== void 0) tomlModel.default_params = model.defaultParams;
+	return tomlModel;
+}
+function toTomlProvider(provider) {
+	const tomlProvider = {
+		endpoint: provider.endpoint,
+		id: provider.id,
+		models: provider.models.map(toTomlModel),
+		type: provider.type
+	};
+	if (provider.headers !== void 0) tomlProvider.headers = provider.headers;
+	return tomlProvider;
+}
+function toTomlRunner(runner) {
+	return {
+		cache: toTomlRunnerCache(runner.cache),
+		file_concurrency: runner.fileConcurrency,
+		rule_concurrency: runner.ruleConcurrency,
+		timeout_ms: runner.timeoutMs
+	};
+}
+function toTomlRunnerCache(cache) {
+	return cache;
+}
+//#endregion
+//#region src/setup-load.ts
+const emptySetupConfig = {
+	providers: [],
+	version: 1
+};
+async function loadSetupConfig(filePath) {
+	try {
+		return parseSetupConfigToml(await readFile(filePath, "utf8"));
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return createEmptySetupConfig();
+		throw error;
+	}
+}
+function mergeSetupConfigs(...configs) {
+	let providers = [];
+	let runner;
+	const providersById = /* @__PURE__ */ new Map();
+	for (const config of configs) {
+		const configProviders = [];
+		if (config.runner !== void 0) runner = {
+			...runner ?? {},
+			...config.runner
+		};
+		for (const provider of config.providers) {
+			const existingProvider = providersById.get(provider.id);
+			if (existingProvider === void 0) {
+				const mergedProvider = cloneProvider(provider);
+				providers.push(mergedProvider);
+				providersById.set(provider.id, mergedProvider);
+				configProviders.push(mergedProvider);
+				continue;
+			}
+			existingProvider.endpoint = provider.endpoint;
+			existingProvider.type = provider.type;
+			configProviders.push(existingProvider);
+			if (provider.headers !== void 0) existingProvider.headers = {
+				...existingProvider.headers,
+				...provider.headers
+			};
+			const nextModels = [];
+			for (const incomingModel of provider.models) {
+				const existingModelIndex = existingProvider.models.findIndex((model) => model.id === incomingModel.id);
+				if (existingModelIndex === -1) {
+					nextModels.push(cloneModel(incomingModel));
+					continue;
+				}
+				const existingModel = existingProvider.models[existingModelIndex];
+				existingProvider.models.splice(existingModelIndex, 1);
+				nextModels.push(mergeModel(existingModel, incomingModel));
+			}
+			existingProvider.models = [...nextModels, ...existingProvider.models];
+		}
+		providers = prioritizeProviders(providers, configProviders);
+	}
+	const mergedConfig = {
+		providers,
+		version: 1
+	};
+	if (runner !== void 0) mergedConfig.runner = runner;
+	return mergedConfig;
+}
+function cloneModel(model) {
+	const clonedModel = { ...model };
+	if (model.aliases !== void 0) clonedModel.aliases = [...model.aliases];
+	if (model.capabilities !== void 0) clonedModel.capabilities = [...model.capabilities];
+	if (model.defaultParams !== void 0) clonedModel.defaultParams = { ...model.defaultParams };
+	return clonedModel;
+}
+function cloneProvider(provider) {
+	const clonedProvider = {
+		...provider,
+		models: provider.models.map(cloneModel)
+	};
+	if (provider.headers !== void 0) clonedProvider.headers = { ...provider.headers };
+	return clonedProvider;
+}
+function createEmptySetupConfig() {
+	return {
+		providers: [],
+		version: 1
+	};
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+function mergeModel(existingModel, incomingModel) {
+	const existing = cloneModel(existingModel);
+	const incoming = cloneModel(incomingModel);
+	return {
+		...existing,
+		...incoming,
+		aliases: incoming.aliases ?? existing.aliases,
+		capabilities: incoming.capabilities ?? existing.capabilities,
+		defaultParams: incoming.defaultParams ?? existing.defaultParams
+	};
+}
+function prioritizeProviders(providers, prioritizedProviders) {
+	const prioritizedProviderIds = new Set(prioritizedProviders.map((provider) => provider.id));
+	return [...prioritizedProviders, ...providers.filter((provider) => !prioritizedProviderIds.has(provider.id))];
+}
+//#endregion
+//#region src/setup-write.ts
+async function writeSetupConfig(filePath, config) {
+	await mkdir(dirname(filePath), { recursive: true });
+	await writeFile(filePath, stringifySetupConfigToml(config), "utf8");
+}
+//#endregion
+export { emptySetupConfig, getGlobalSetupConfigPath, getProjectSetupConfigPath, loadAlintConfig, loadSetupConfig, mergeSetupConfigs, parseSetupConfigToml, stringifySetupConfigToml, writeSetupConfig };

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@alint-js/config",
+  "type": "module",
+  "version": "0.0.4",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "c12": "^3.3.4",
+    "pathe": "^2.0.3",
+    "smol-toml": "^1.7.0",
+    "xdg-basedir": "^5.1.0",
+    "@alint-js/core": "0.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "tsdown": "^0.22.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --config vitest.config.ts"
+  }
+}