@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/config/cfg-unstable.js

@@ -0,0 +1,41 @@
+import { Value } from "@sinclair/typebox/value";
+import { loadConfig, watchConfig } from "c12";
+import { DEFAULT_CONFIG_RSE } from "./cfg-default.js";
+import { rseSchema } from "./cfg-schema.js";
+export async function loadrse(projectPath) {
+  const { config } = await loadConfig({
+    cwd: projectPath,
+    name: "rse",
+    configFile: "rse",
+    // will look for files like `rse.{ts,jsonc}`
+    rcFile: false,
+    packageJson: false,
+    dotenv: false,
+    // disable loading .env
+    defaults: DEFAULT_CONFIG_RSE
+    // merged first
+    // overrides: overrides || {}, // highest priority
+  });
+  if (!Value.Check(rseSchema, config)) {
+    const errors = [...Value.Errors(rseSchema, config)].map(
+      (err) => `Path "${err.path}": ${err.message}`
+    );
+    throw new Error(`Invalid rse config:
+${errors.join("\n")}`);
+  }
+  return config;
+}
+export async function watchrse(projectPath, onUpdate) {
+  const watcher = await watchConfig({
+    cwd: projectPath,
+    name: "rse",
+    onUpdate({ newConfig, getDiff }) {
+      if (!Value.Check(rseSchema, newConfig)) {
+        return;
+      }
+      onUpdate(newConfig);
+      console.log("Diff:", getDiff());
+    }
+  });
+  console.log("Watching config:", watcher.watchingFiles);
+}

package/bin/app/config/cfg-update.d.ts

@@ -0,0 +1,10 @@
+import type { RseConfig } from "../types/mod.js";
+/**
+ * Updates project configuration by merging new updates with the existing config.
+ * Creates a backup before overwriting and attempts to restore from backup on error.
+ */
+export declare function updateRseConfig(projectPath: string, updates: Partial<RseConfig>, isDev: boolean): Promise<boolean>;
+/**
+ * Merges a partial config with the default config.
+ */
+export declare function mergeWithDefaults(partial: Partial<RseConfig>): RseConfig;

package/bin/app/config/cfg-update.js

@@ -0,0 +1,152 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { Value } from "@sinclair/typebox/value";
+import { parseJSONC } from "confbox";
+import { writeRseConfig } from "./cfg-create.js";
+import { DEFAULT_CONFIG_RSE } from "./cfg-default.js";
+import { getRseConfigPath } from "./cfg-path.js";
+import { rseSchema } from "./cfg-schema.js";
+import { getBackupAndTempPaths } from "./cfg-utils.js";
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (!Object.hasOwn(source, key)) continue;
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue !== void 0) {
+      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        result[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+function findObjectDifferences(obj1, obj2, path = "") {
+  const differences = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
+  for (const key of allKeys) {
+    const currentPath = path ? `${path}.${key}` : key;
+    const val1 = obj1[key];
+    const val2 = obj2[key];
+    if (val1 === void 0 || val2 === void 0) {
+      differences.push(`${currentPath}: ${val1 === void 0 ? "removed" : "added"}`);
+      continue;
+    }
+    if (typeof val1 === "object" && val1 !== null && typeof val2 === "object" && val2 !== null) {
+      if (Array.isArray(val1) && Array.isArray(val2)) {
+        if (JSON.stringify(val1) !== JSON.stringify(val2)) {
+          differences.push(`${currentPath}: array values differ`);
+        }
+      } else {
+        differences.push(
+          ...findObjectDifferences(
+            val1,
+            val2,
+            currentPath
+          )
+        );
+      }
+    } else if (val1 !== val2) {
+      differences.push(`${currentPath}: ${JSON.stringify(val1)} \u2192 ${JSON.stringify(val2)}`);
+    }
+  }
+  return differences;
+}
+function filterMemoryFields(config) {
+  const { code, key, ...rest } = config;
+  return rest;
+}
+export async function updateRseConfig(projectPath, updates, isDev) {
+  const { configPath } = await getRseConfigPath(projectPath, isDev, false);
+  const { backupPath, tempPath } = getBackupAndTempPaths(configPath);
+  try {
+    let existingConfig = {};
+    if (await fs.pathExists(configPath)) {
+      const existingContent = await fs.readFile(configPath, "utf-8");
+      const parsed = parseJSONC(existingContent);
+      if (Value.Check(rseSchema, parsed)) {
+        existingConfig = parsed;
+      } else {
+        relinka("warn", "Invalid config schema, starting fresh");
+      }
+    }
+    const filteredUpdates = filterMemoryFields(updates);
+    const mergedConfig = deepMerge(existingConfig, filteredUpdates);
+    if (!Value.Check(rseSchema, mergedConfig)) {
+      const issues = [...Value.Errors(rseSchema, mergedConfig)].map(
+        (err) => `Path "${err.path}": ${err.message}`
+      );
+      relinka("error", "Invalid config after merge:", issues.join("; "));
+      return false;
+    }
+    const differences = findObjectDifferences(existingConfig, mergedConfig);
+    if (differences.length === 0) {
+      relinka("verbose", "No changes detected in config, skipping update");
+      return true;
+    }
+    relinka("info", "Config changes detected:");
+    for (const diff of differences) {
+      relinka("info", `  ${diff}`);
+    }
+    if (await fs.pathExists(configPath)) {
+      await fs.copy(configPath, backupPath);
+    }
+    await writeRseConfig(configPath, mergedConfig, isDev);
+    if (await fs.pathExists(backupPath)) {
+      await fs.remove(backupPath);
+    }
+    relinka("null", "");
+    relinka("success", "rse config updated successfully");
+    return true;
+  } catch (error) {
+    relinka("error", "Failed to update config:", String(error));
+    if (await fs.pathExists(backupPath) && !await fs.pathExists(configPath)) {
+      try {
+        await fs.copy(backupPath, configPath);
+        relinka("warn", "Restored config from backup after failed update");
+      } catch (restoreError) {
+        relinka("error", "Failed to restore config from backup:", String(restoreError));
+      }
+    }
+    if (await fs.pathExists(tempPath)) {
+      await fs.remove(tempPath);
+    }
+    return false;
+  }
+}
+export function mergeWithDefaults(partial) {
+  return {
+    ...DEFAULT_CONFIG_RSE,
+    ...partial,
+    features: {
+      ...DEFAULT_CONFIG_RSE.features,
+      ...partial.features ?? {}
+    },
+    codeStyle: {
+      ...DEFAULT_CONFIG_RSE.codeStyle ?? {},
+      ...partial.codeStyle ?? {},
+      modernize: {
+        ...DEFAULT_CONFIG_RSE.codeStyle?.modernize ?? {},
+        ...partial.codeStyle?.modernize ?? {}
+      }
+    },
+    preferredLibraries: {
+      ...DEFAULT_CONFIG_RSE.preferredLibraries,
+      ...partial.preferredLibraries ?? {}
+    },
+    monorepo: {
+      ...DEFAULT_CONFIG_RSE.monorepo,
+      ...partial.monorepo ?? {}
+    },
+    customRules: {
+      ...DEFAULT_CONFIG_RSE.customRules,
+      ...partial.customRules ?? {}
+    },
+    ignoreDependencies: partial.ignoreDependencies ?? DEFAULT_CONFIG_RSE.ignoreDependencies
+  };
+}

package/bin/app/config/cfg-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cleans GitHub repository URLs by removing git+ prefix and .git suffix.
+ */
+export declare function cleanGitHubUrl(url: string): string;
+export declare function objectToCodeString(obj: any, indentLevel?: number): string;
+export declare function updateTsConfigInclude(projectPath: string): Promise<void>;
+/**
+ * Returns the backup and temporary file paths for a given config file.
+ */
+export declare function getBackupAndTempPaths(configPath: string): {
+    backupPath: string;
+    tempPath: string;
+};
+/**
+ * Helper to atomically write a file with backup and temporary file handling.
+ */
+export declare function atomicWriteFile(filePath: string, content: string, backupPath: string, tempPath: string): Promise<void>;

package/bin/app/config/cfg-utils.js

@@ -0,0 +1,85 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { readTSConfig, writeTSConfig } from "pkg-types";
+import { cliConfigTs, tsconfigJson } from "./constants.js";
+export function cleanGitHubUrl(url) {
+  return url.trim().replace(/^git\+/, "").replace(/^https?:\/\/(www\.)?(github|gitlab|bitbucket|sourcehut)\.com\//i, "").replace(/^(github|gitlab|bitbucket|sourcehut)\.com\//i, "").replace(/\.git$/i, "");
+}
+function isValidIdentifier(key) {
+  const identifierRegex = /^[A-Za-z_$][0-9A-Za-z_$]*$/;
+  return identifierRegex.test(key);
+}
+export function objectToCodeString(obj, indentLevel = 0) {
+  const indent = "  ".repeat(indentLevel);
+  const indentNext = "  ".repeat(indentLevel + 1);
+  if (obj === null) return "null";
+  if (typeof obj === "string") return JSON.stringify(obj);
+  if (typeof obj === "number" || typeof obj === "boolean") return String(obj);
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    const items = obj.map((item) => objectToCodeString(item, indentLevel + 1));
+    return `[
+${items.map((item) => `${indentNext}${item}`).join(",\n")}
+${indent}]`;
+  }
+  if (typeof obj === "object") {
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return "{}";
+    const lines = keys.map((key) => {
+      const formattedKey = isValidIdentifier(key) ? key : JSON.stringify(key);
+      const valueStr = objectToCodeString(obj[key], indentLevel + 1);
+      return `${indentNext}${formattedKey}: ${valueStr}`;
+    });
+    return `{
+${lines.join(",\n")}
+${indent}}`;
+  }
+  return String(obj);
+}
+export async function updateTsConfigInclude(projectPath) {
+  const tsconfigPath = path.join(projectPath, tsconfigJson);
+  if (!await fs.pathExists(tsconfigPath)) return;
+  try {
+    const tsconfig = await readTSConfig(projectPath);
+    tsconfig.include = Array.isArray(tsconfig.include) ? tsconfig.include : [];
+    if (!tsconfig.include.includes(cliConfigTs)) {
+      tsconfig.include.push(cliConfigTs);
+      await writeTSConfig(tsconfigPath, tsconfig);
+      relinka("verbose", "Updated tsconfig.json to include reliverse.ts");
+    }
+  } catch (err) {
+    relinka(
+      "warn",
+      "Failed to update tsconfig.json:",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
+}
+export function getBackupAndTempPaths(configPath) {
+  const configDir = path.dirname(configPath);
+  const baseName = path.basename(configPath);
+  if (configPath.endsWith(".ts")) {
+    return {
+      backupPath: path.join(configDir, `${baseName}.bak`),
+      tempPath: path.join(configDir, `${baseName}.tmp`)
+    };
+  }
+  return {
+    backupPath: path.join(configDir, `${baseName}.bak`),
+    tempPath: path.join(configDir, `${baseName}.tmp`)
+  };
+}
+export async function atomicWriteFile(filePath, content, backupPath, tempPath) {
+  if (await fs.pathExists(backupPath)) {
+    await fs.remove(backupPath);
+  }
+  if (await fs.pathExists(filePath)) {
+    await fs.copy(filePath, backupPath);
+  }
+  await fs.writeFile(tempPath, content, "utf-8");
+  await fs.rename(tempPath, filePath);
+  if (await fs.pathExists(backupPath)) {
+    await fs.remove(backupPath);
+  }
+}

package/bin/app/config/cmd.js

@@ -1,6 +1,6 @@
 import { relinka } from "@reliverse/relinka";
 import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { ensureConfigMod } from "../../libs/sdk/sdk-impl/config/core.js";
+import { ensureConfigMod } from "./core.js";
 export default defineCommand({
   meta: {
     name: "config",

package/bin/app/config/constants.d.ts

@@ -0,0 +1,44 @@
+export declare const PROJECT_ROOT: string;
+export declare const cliVersion = "1.7.93";
+export declare const cliName = "@reliverse/rse";
+export declare const rseName = "@reliverse/rse";
+export declare const dlerName = "@reliverse/dler";
+export declare const tsconfigJson = "tsconfig.json";
+export declare const cliConfigJsonc = "reliverse.jsonc";
+export declare const cliConfigJsoncTmp = "reliverse.jsonc.tmp";
+export declare const cliConfigJsoncBak = "reliverse.jsonc.bak";
+export declare const cliConfigTs = "reliverse.ts";
+export declare const cliConfigTsTmp = "reliverse.ts.tmp";
+export declare const cliConfigTsBak = "reliverse.ts.bak";
+export declare const rseOrg = "https://reliverse.org";
+export declare const rseOrgBase = "reliverse.org";
+export declare const cliDomainRoot = "https://docs.reliverse.org";
+export declare const cliDomainDocs = "https://docs.reliverse.org/cli";
+export declare const cliDomainEnv = "https://docs.reliverse.org/env";
+export declare const homeDir: any;
+export declare const cliHomeDir: string;
+export declare const cliHomeTmp: string;
+export declare const cliHomeRepos: string;
+export declare const memoryPath: string;
+export declare const cliJsrPath: string;
+export declare const useLocalhost = false;
+export declare const DEFAULT_CLI_USERNAME = "johnny911";
+export declare const endTitle = "\uD83D\uDCDA Check the docs to learn more: https://docs.reliverse.org/cli";
+export declare const UNKNOWN_VALUE = "unknown";
+export declare const DEFAULT_DOMAIN = "https://example.com";
+export declare const RSE_SCHEMA_DEV = "./schema.json";
+export declare const RSE_SCHEMA_URL = "https://reliverse.org/schema.json";
+export declare const FALLBACK_ENV_EXAMPLE_URL = "https://raw.githubusercontent.com/blefnk/relivator/main/.env.example";
+export declare const CONFIG_CATEGORIES: {
+    readonly core: readonly ["reliverse.jsonc", "reliverse.ts"];
+    readonly linting: readonly ["biome.json"];
+    readonly ide: readonly [".vscode/settings.json"];
+    readonly git: readonly [".gitignore"];
+};
+export declare const IGNORE_PATTERNS: readonly ["node_modules", ".git", ".next", ".vercel", "coverage", ".nyc_output", "dist", "build", ".cache", ".temp", ".tmp"];
+export declare const CONCURRENCY_DEFAULT = 1;
+export declare const validExtensions: string[];
+export declare const SHOW_VERBOSE: {
+    getDirectorySize: boolean;
+    readFileSafe: boolean;
+};

package/bin/app/config/constants.js

@@ -0,0 +1,59 @@
+import os from "node:os";
+import path from "@reliverse/pathkit";
+export const PROJECT_ROOT = path.resolve(process.cwd());
+const version = "1.7.93";
+export const cliVersion = version;
+export const cliName = "@reliverse/rse";
+export const rseName = "@reliverse/rse";
+export const dlerName = "@reliverse/dler";
+export const tsconfigJson = "tsconfig.json";
+export const cliConfigJsonc = "reliverse.jsonc";
+export const cliConfigJsoncTmp = "reliverse.jsonc.tmp";
+export const cliConfigJsoncBak = "reliverse.jsonc.bak";
+export const cliConfigTs = "reliverse.ts";
+export const cliConfigTsTmp = "reliverse.ts.tmp";
+export const cliConfigTsBak = "reliverse.ts.bak";
+export const rseOrg = "https://reliverse.org";
+export const rseOrgBase = `reliverse.org`;
+export const cliDomainRoot = `https://docs.reliverse.org`;
+export const cliDomainDocs = `https://docs.reliverse.org/cli`;
+export const cliDomainEnv = `https://docs.reliverse.org/env`;
+export const homeDir = os.homedir();
+export const cliHomeDir = path.join(homeDir, ".reliverse", "rse");
+export const cliHomeTmp = path.join(cliHomeDir, "temp");
+export const cliHomeRepos = path.join(cliHomeDir, "repos");
+export const memoryPath = path.join(cliHomeDir, "memory.db");
+export const cliJsrPath = path.join(cliHomeDir, "cli");
+export const useLocalhost = false;
+export const DEFAULT_CLI_USERNAME = "johnny911";
+export const endTitle = `\u{1F4DA} Check the docs to learn more: ${cliDomainDocs}`;
+export const UNKNOWN_VALUE = "unknown";
+export const DEFAULT_DOMAIN = "https://example.com";
+export const RSE_SCHEMA_DEV = "./schema.json";
+export const RSE_SCHEMA_URL = `${rseOrg}/schema.json`;
+export const FALLBACK_ENV_EXAMPLE_URL = "https://raw.githubusercontent.com/blefnk/relivator/main/.env.example";
+export const CONFIG_CATEGORIES = {
+  core: [cliConfigJsonc, cliConfigTs],
+  linting: ["biome.json"],
+  ide: [".vscode/settings.json"],
+  git: [".gitignore"]
+};
+export const IGNORE_PATTERNS = [
+  "node_modules",
+  ".git",
+  ".next",
+  ".vercel",
+  "coverage",
+  ".nyc_output",
+  "dist",
+  "build",
+  ".cache",
+  ".temp",
+  ".tmp"
+];
+export const CONCURRENCY_DEFAULT = 1;
+export const validExtensions = ["cjs", "js", "mjs", "ts", "mts", "cts"];
+export const SHOW_VERBOSE = {
+  getDirectorySize: false,
+  readFileSafe: false
+};

package/bin/app/config/core.js

@@ -0,0 +1,231 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { createJiti } from "jiti";
+import ky from "ky";
+import MagicString from "magic-string";
+import { readPackageJSON } from "pkg-types";
+export async function ensureConfigMod(options) {
+  console.log("ensureConfigMod", options);
+  const { tool, mode, forceUpdate = false, isDev = false } = options;
+  const configModPath = path.resolve(process.cwd(), "mod.ts");
+  const pkg = await readPackageJSON().catch(() => ({ version: "1.0.0" }));
+  let dotConfig = {};
+  if (await fs.pathExists(configModPath) && !forceUpdate) {
+    try {
+      const jiti = createJiti(import.meta.url);
+      const existingConfig2 = await jiti.import(configModPath);
+      if (existingConfig2?.dotConfig && typeof existingConfig2.dotConfig === "object") {
+        dotConfig = existingConfig2.dotConfig;
+      }
+    } catch (error) {
+      relinka(
+        "warn",
+        `Could not import existing mod.ts: ${error instanceof Error ? error.message : String(error)}`
+      );
+      try {
+        const content = await fs.readFile(configModPath, "utf8");
+        dotConfig = parseConfigManually(content);
+      } catch (parseError) {
+        relinka("warn", `Manual parsing also failed, starting with empty config`);
+      }
+    }
+  }
+  const pkgVersion = pkg.version ?? "1.0.0";
+  const toolConfig = {
+    version: pkgVersion,
+    mode,
+    main: "defineConfig",
+    input: getInputSource(tool, mode, isDev),
+    output: `types/${tool}.schema.ts`
+  };
+  const existingConfig = dotConfig[tool];
+  const shouldDownloadSchema = await shouldUpdateSchema(existingConfig, toolConfig);
+  dotConfig[tool] = toolConfig;
+  const modContent = generateConfigModContent(dotConfig);
+  await fs.outputFile(configModPath, modContent, { encoding: "utf8" });
+  if (shouldDownloadSchema) {
+    await processSchema(toolConfig.input, toolConfig.output, mode);
+    const action = mode === "copy-internal" ? "Copied" : "Downloaded";
+    relinka("info", `${action} fresh types for ${tool} v${pkgVersion}`);
+  } else {
+    relinka("info", `Types for ${tool} v${pkgVersion} are up to date, skipping download`);
+  }
+  await updateToolConfigImports(tool, toolConfig.main);
+  relinka("success", `Updated mod.ts with ${tool} configuration`);
+}
+async function shouldUpdateSchema(existingConfig, newConfig) {
+  if (!existingConfig) {
+    return true;
+  }
+  if (existingConfig.version !== newConfig.version) {
+    relinka("info", `Version changed from ${existingConfig.version} to ${newConfig.version}`);
+    return true;
+  }
+  if (existingConfig.input !== newConfig.input) {
+    relinka("info", `Schema input URL changed`);
+    return true;
+  }
+  const outputPath = path.resolve(process.cwd(), newConfig.output);
+  if (!await fs.pathExists(outputPath)) {
+    relinka("info", `Schema file ${newConfig.output} does not exist`);
+    return true;
+  }
+  if (existingConfig.mode !== newConfig.mode || existingConfig.main !== newConfig.main) {
+    relinka("info", `Configuration mode or main export changed`);
+    return true;
+  }
+  return false;
+}
+function getInputSource(tool, mode, isDev) {
+  if (mode === "copy-internal") {
+    const sourceDir = isDev ? "src" : "bin";
+    return `${sourceDir}/libs/cfg/cfg-dler.ts`;
+  } else {
+    return getSchemaUrl(tool);
+  }
+}
+async function processSchema(input, outputPath, mode) {
+  if (mode === "copy-internal") {
+    await copyInternalSchema(input, outputPath);
+  } else {
+    await downloadSchema(input, outputPath);
+  }
+}
+async function copyInternalSchema(inputPath, outputPath) {
+  try {
+    const fullInputPath = path.resolve(process.cwd(), inputPath);
+    const fullOutputPath = path.resolve(process.cwd(), outputPath);
+    if (!await fs.pathExists(fullInputPath)) {
+      throw new Error(`Internal schema file not found: ${inputPath}`);
+    }
+    const content = await fs.readFile(fullInputPath, "utf8");
+    await fs.outputFile(fullOutputPath, content, { encoding: "utf8" });
+    relinka("success", `Copied internal schema from ${inputPath} to ${outputPath}`);
+  } catch (error) {
+    relinka(
+      "error",
+      `Failed to copy internal schema: ${error instanceof Error ? error.message : String(error)}`
+    );
+    throw error;
+  }
+}
+function parseConfigManually(content) {
+  try {
+    const exportMatch = content.match(/export const dotConfig[^=]*=\s*({[\s\S]*?});/);
+    if (!exportMatch?.[1]) {
+      return {};
+    }
+    const objStr = exportMatch[1].replace(/(\w+):/g, '"$1":').replace(/'/g, '"').replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(objStr);
+  } catch (error) {
+    relinka(
+      "warn",
+      `Failed to manually parse config: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {};
+  }
+}
+function getSchemaUrl(tool) {
+  const schemaUrls = {
+    dler: "https://raw.githubusercontent.com/blefnk/temp/refs/heads/main/dler-types.ts",
+    rse: "https://raw.githubusercontent.com/blefnk/temp/refs/heads/main/rse-types.ts"
+  };
+  return schemaUrls[tool] || schemaUrls.dler;
+}
+async function downloadSchema(inputUrl, outputPath) {
+  try {
+    const response = await ky.get(inputUrl);
+    const content = await response.text();
+    const fullOutputPath = path.resolve(process.cwd(), outputPath);
+    await fs.outputFile(fullOutputPath, content, { encoding: "utf8" });
+    relinka("success", `Downloaded schema to ${outputPath}`);
+  } catch (error) {
+    relinka(
+      "error",
+      `Failed to download schema: ${error instanceof Error ? error.message : String(error)}`
+    );
+    throw error;
+  }
+}
+async function updateToolConfigImports(tool, mainExport) {
+  const configPath = path.resolve(process.cwd(), `${tool}.ts`);
+  if (!await fs.pathExists(configPath)) {
+    relinka("warn", `Config file ${tool}.ts not found, skipping import update`);
+    return;
+  }
+  try {
+    const content = await fs.readFile(configPath, "utf8");
+    const s = new MagicString(content);
+    const schemaImportPath = `./types/${tool}.schema`;
+    const newImportStatement = `import { ${mainExport} } from "${schemaImportPath}";`;
+    if (content.includes(schemaImportPath)) {
+      relinka("info", `Import already exists in ${tool}.ts`);
+      return;
+    }
+    const existingImportRegex = /import\s*{\s*defineConfig\s*}\s*from\s*[^;]+;/;
+    const existingImportMatch = content.match(existingImportRegex);
+    if (existingImportMatch) {
+      const start = content.indexOf(existingImportMatch[0]);
+      const end = start + existingImportMatch[0].length;
+      s.overwrite(start, end, newImportStatement);
+    } else {
+      const lines = content.split("\n");
+      let insertIndex = 0;
+      let insertLine = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i]?.trim();
+        if (line && line.startsWith("import ")) {
+          insertLine = i + 1;
+          insertIndex = content.indexOf(lines[i]) + lines[i].length + 1;
+        } else if (line === "") {
+        } else if (line) {
+          break;
+        }
+      }
+      if (insertLine === 0) {
+        s.prepend(newImportStatement + "\n\n");
+      } else {
+        s.appendLeft(insertIndex, newImportStatement + "\n");
+      }
+    }
+    const updatedContent = s.toString();
+    await fs.writeFile(configPath, updatedContent, "utf8");
+    relinka("success", `Updated imports in ${tool}.ts`);
+  } catch (error) {
+    relinka(
+      "error",
+      `Failed to update imports: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function generateConfigModContent(dotConfig) {
+  const s = new MagicString("");
+  s.append("// autogenerated by `dler config`\n");
+  s.append("// don't edit this file manually\n\n");
+  const interfaceDefinition = generateDotConfigInterface(dotConfig);
+  s.append(interfaceDefinition);
+  s.append("\n\n");
+  s.append("export const dotConfig: DotConfig = ");
+  s.append(JSON.stringify(dotConfig, null, 2));
+  s.append(";\n");
+  return s.toString();
+}
+function generateDotConfigInterface(dotConfig) {
+  const s = new MagicString("");
+  const toolNames = Object.keys(dotConfig);
+  s.append("export interface ConfigModEntry {\n");
+  s.append("  version: string;\n");
+  s.append("  mode: string;\n");
+  s.append("  main: string;\n");
+  s.append("  input: string;\n");
+  s.append("  output: string;\n");
+  s.append("}\n\n");
+  s.append("export interface DotConfig {\n");
+  toolNames.forEach((tool) => {
+    s.append(`  ${tool}?: ConfigModEntry;
+`);
+  });
+  s.append("}");
+  return s.toString();
+}

package/bin/app/config/default.d.ts

@@ -0,0 +1,6 @@
+import type { DlerConfig } from "../types/mod.js";
+/**
+ * Default configuration for the build and publish logic.
+ */
+export declare const DEFAULT_CONFIG_DLER: DlerConfig;
+export declare const defineConfig: (userConfig?: Partial<DlerConfig>) => any;