ts-ag 1.0.19 → 1.0.20

package/dist/scripts/ts-alias.d.ts

@@ -1,3 +1,3 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 export {};
 //# sourceMappingURL=ts-alias.d.ts.map

package/dist/scripts/ts-alias.js

@@ -1,16 +1,20 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import console from 'console';
 // NOTE: dont use aliases here cause this file needs to be compiled first
-import { existsSync, statSync, readFileSync } from 'fs';
-import { dirname, join, basename } from 'path';
+import { existsSync } from 'fs';
+import { dirname, join, basename, relative } from 'path';
 import { watch } from 'chokidar';
 import { glob } from 'glob';
 import { replaceTscAliasPaths } from 'tsc-alias';
-// Cache for tsconfig.json files
-const tsconfigCache = new Map();
+import { colorText } from '../utils/cli.js';
 // Parse command-line arguments
 const args = process.argv.slice(2);
 const watchMode = args.includes('-w') || args.includes('--watch');
+const LABEL = colorText('cyan', '[ts-alias]');
+const formatPath = (filePath) => colorText('dim', relative(process.cwd(), filePath));
+const logInfo = (message) => console.log(`${LABEL} ${message}`);
+const logWarn = (message) => console.warn(`${LABEL} ${colorText('yellow', message)}`);
+const logError = (message) => console.error(`${LABEL} ${colorText('red', message)}`);
 /**
  * Find all dist folders in the project directory, excluding certain patterns.
  */
@@ -27,31 +31,6 @@ async function findDistFolders(baseDir) {
     const distFolders = await glob('**/dist', { cwd: baseDir, ignore: ignorePatterns, absolute: true });
     return distFolders;
 }
-/**
- * Get the tsconfig.json file for a given dist folder.
- * This function caches the tsconfig file to avoid reading it multiple times.
- */
-function getTsconfig(distFolder) {
-    const projectRoot = dirname(distFolder);
-    const tsconfigPath = join(projectRoot, 'tsconfig.json');
-    try {
-        const stats = statSync(tsconfigPath);
-        const mtime = stats.mtimeMs;
-        // Check cache
-        const cached = tsconfigCache.get(tsconfigPath);
-        if (cached && cached.mtime === mtime) {
-            return cached.config;
-        }
-        // Read and cache the config
-        const config = JSON.parse(readFileSync(tsconfigPath, 'utf8'));
-        tsconfigCache.set(tsconfigPath, { config, mtime });
-        return config;
-    }
-    catch (error) {
-        console.error(`Error reading tsconfig at ${tsconfigPath}:`, error);
-        return null;
-    }
-}
 /**
  * Process the dist folder by replacing TypeScript alias paths with relative paths.
  */
@@ -59,42 +38,44 @@ async function processDistFolder(distFolder) {
     const projectRoot = dirname(distFolder);
     const tsconfigPath = join(projectRoot, 'tsconfig.json');
     if (!existsSync(tsconfigPath)) {
-        console.warn(`No tsconfig.json found at ${tsconfigPath}`);
-        return;
-    }
-    const tsconfig = getTsconfig(distFolder);
-    if (!tsconfig) {
-        console.warn(`Invalid tsconfig.json found for ${distFolder}`);
+        logWarn(`No tsconfig.json at ${formatPath(tsconfigPath)}`);
         return;
     }
     try {
         await replaceTscAliasPaths({ configFile: tsconfigPath, outDir: distFolder });
-        console.log(`Successfully processed aliases in ${distFolder}`);
+        logInfo(`${colorText('green', 'updated')} ${formatPath(distFolder)}`);
     }
     catch (error) {
-        console.error(`Error processing aliases in ${distFolder}:`, error);
+        logError(`Failed processing ${formatPath(distFolder)}`);
+        console.error(error);
     }
 }
 /**
  * Watch the dist folder for changes and process it when files are added or changed.
  */
 function watchDistFolder(distFolder) {
-    console.log(`Setting up watcher for: ${distFolder}`);
+    let pending = null;
     const watcher = watch(distFolder, {
         persistent: true,
         ignoreInitial: true,
         awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
     });
+    const scheduleProcess = () => {
+        if (pending)
+            clearTimeout(pending);
+        pending = setTimeout(() => {
+            pending = null;
+            void processDistFolder(distFolder);
+        }, 200);
+    };
     watcher.on('add', (filePath) => {
         if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
-            console.log(`File added: ${filePath}`);
-            processDistFolder(distFolder);
+            scheduleProcess();
         }
     });
     watcher.on('change', (filePath) => {
         if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
-            console.log(`File changed: ${filePath}`);
-            processDistFolder(distFolder);
+            scheduleProcess();
         }
     });
     return watcher;
@@ -102,26 +83,25 @@ function watchDistFolder(distFolder) {
 // Main function
 async function main() {
     const baseDir = process.cwd();
-    console.log(`Searching for dist folders in: ${baseDir}`);
+    logInfo(`searching ${colorText('cyan', 'dist')} folders in ${formatPath(baseDir)}`);
     const distFolders = await findDistFolders(baseDir);
     // Process all folders initially if any exist
     if (distFolders.length > 0) {
-        console.log(`Found ${distFolders.length} dist folders:`);
-        distFolders.forEach((folder) => console.log(` - ${folder}`));
-        for (const folder of distFolders) {
-            await processDistFolder(folder);
-        }
+        logInfo(`found ${distFolders.length} dist folder(s)`);
+        await Promise.all(distFolders.map(async (folder) => {
+            return await processDistFolder(folder);
+        }));
     }
     else {
-        console.log('No dist folders found initially');
+        logInfo('no dist folders found');
     }
     // Set up watchers if in watch mode
     if (watchMode) {
-        console.log('Watch mode enabled, monitoring for changes...');
+        logInfo('watch mode enabled');
         // Set up watchers for existing dist folders
         distFolders.forEach(watchDistFolder);
         // Watch for new dist folders being created
-        console.log('Watching for new dist folders...');
+        logInfo('watching for new dist folders...');
         const dirWatcher = watch(baseDir, {
             persistent: true,
             ignoreInitial: true,
@@ -143,7 +123,7 @@ async function main() {
             if (basename(dirPath) === 'dist') {
                 // Make sure it's not already being watched
                 if (!distFolders.includes(dirPath)) {
-                    console.log(`New dist folder detected: ${dirPath}`);
+                    logInfo(`${colorText('cyan', 'new dist')} ${formatPath(dirPath)}`);
                     distFolders.push(dirPath);
                     await processDistFolder(dirPath);
                     watchDistFolder(dirPath);
@@ -153,6 +133,7 @@ async function main() {
     }
 }
 main().catch((error) => {
-    console.error('Error in ts-alias script:', error);
+    logError('Unhandled error in ts-alias script');
+    console.error(error);
     process.exit(1);
 });

package/dist/scripts/ts-build-config.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=ts-build-config.d.ts.map

package/dist/scripts/ts-build-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-build-config.d.ts","sourceRoot":"","sources":["../../src/scripts/ts-build-config.ts"],"names":[],"mappings":""}

package/dist/scripts/ts-build-config.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env bun
+import console from 'console';
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
+import { dirname, join, resolve, relative } from 'path';
+import { parseArgs } from 'util';
+import { watch } from 'chokidar';
+import { getTsconfig } from 'get-tsconfig';
+import { colorText } from '../utils/cli.js';
+const DEFAULT_TEST_EXCLUDES = [
+    '**/*.test.ts',
+    '**/*.test.tsx',
+    '**/*.spec.ts',
+    '**/*.spec.tsx',
+    '**/__tests__/**',
+    '**/tests/**'
+];
+const GENERATED_FILE_HEADER = '// generated by ts-build-config';
+const LABEL = colorText('cyan', '[ts-build-config]');
+const formatPath = (filePath) => colorText('dim', relative(process.cwd(), filePath));
+const logInfo = (message) => console.log(`${LABEL} ${message}`);
+const logWarn = (message) => console.warn(`${LABEL} ${colorText('yellow', message)}`);
+const logError = (message) => console.error(`${LABEL} ${colorText('red', message)}`);
+function asArray(v) {
+    if (!v)
+        return [];
+    return Array.isArray(v) ? v : [v];
+}
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function uniq(items) {
+    return Array.from(new Set(items));
+}
+function normalizeRefPath(baseTsconfigPath, refPath) {
+    // TS project references are relative to the tsconfig location
+    const baseDir = dirname(baseTsconfigPath);
+    // refPath may point to a folder (containing tsconfig.json) or a file
+    const abs = resolve(baseDir, refPath);
+    return abs;
+}
+function resolveReferencedTsconfigPath(refAbsPath) {
+    // If they referenced a file directly, use it
+    if (refAbsPath.endsWith('.json')) {
+        return existsSync(refAbsPath) ? refAbsPath : null;
+    }
+    // Otherwise assume it's a directory containing tsconfig.json
+    const candidate = join(refAbsPath, 'tsconfig.json');
+    if (existsSync(candidate))
+        return candidate;
+    // Some repos use tsconfig.base.json or similar; we won't guess.
+    return null;
+}
+function readTsconfig(tsconfigPath) {
+    const res = getTsconfig(tsconfigPath);
+    if (!res) {
+        throw new Error(`get-tsconfig could not load: ${tsconfigPath}`);
+    }
+    // get-tsconfig returns a parsed config object (includes extends resolved).
+    // We want to write a build tsconfig that extends the original file path,
+    // so we mostly only need top-level fields we change (exclude/compilerOptions).
+    return res.config;
+}
+function computeExtraExcludes(config) {
+    const extra = [...DEFAULT_TEST_EXCLUDES];
+    // If the tsconfig includes ./tests (or tests) explicitly, ensure it is excluded in build config.
+    const includes = asArray(config.include);
+    for (const inc of includes) {
+        const norm = inc.replace(/\\/g, '/').replace(/\/+$/, '');
+        if (norm === './tests' || norm === 'tests' || norm.startsWith('./tests/') || norm.startsWith('tests/')) {
+            extra.push('./tests/**');
+            break;
+        }
+    }
+    return uniq(extra);
+}
+function writeBuildTsconfig(tsconfigPath, config, dryRun) {
+    const dir = dirname(tsconfigPath);
+    const outPath = join(dir, 'tsconfig.build.json');
+    const existingExclude = asArray(config.exclude);
+    const mergedExclude = uniq([...existingExclude, ...computeExtraExcludes(config)]);
+    const buildConfig = { extends: './tsconfig.json', compilerOptions: {}, exclude: mergedExclude };
+    // If original compilerOptions exists, keep build-specific overrides minimal.
+    // But ensure emit is enabled if base tsconfig has noEmit: true (common for editor configs).
+    const baseCO = isObject(config.compilerOptions) ? config.compilerOptions : {};
+    if (baseCO.noEmit === true) {
+        buildConfig.compilerOptions.noEmit = false;
+    }
+    // Keep outDir/rootDir if already set in base; do not guess.
+    // If you want to force them, do it in the base tsconfig.json or pass flags later.
+    if (!dryRun) {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(outPath, `${GENERATED_FILE_HEADER}\n${JSON.stringify(buildConfig, null, 2)}\n`, 'utf8');
+    }
+    return outPath;
+}
+function isGeneratedByThisScript(filePath) {
+    try {
+        const contents = readFileSync(filePath, 'utf8');
+        const firstLine = contents.split(/\r?\n/, 1)[0]?.trim() ?? '';
+        return firstLine === GENERATED_FILE_HEADER;
+    }
+    catch {
+        return false;
+    }
+}
+function getProjectRefs(tsconfigPath, config) {
+    const refs = asArray(config.references);
+    const result = [];
+    for (const r of refs) {
+        if (!r)
+            continue;
+        const refPath = typeof r === 'string' ? r : r.path;
+        if (!refPath || typeof refPath !== 'string')
+            continue;
+        const abs = normalizeRefPath(tsconfigPath, refPath);
+        const resolved = resolveReferencedTsconfigPath(abs);
+        if (resolved)
+            result.push(resolved);
+    }
+    return uniq(result);
+}
+function generateBuildConfigs(entry, options) {
+    const { dryRun, force, verbose } = options;
+    const visited = new Set();
+    const queue = [entry];
+    const created = [];
+    while (queue.length) {
+        const tsconfigPath = queue.shift();
+        if (visited.has(tsconfigPath))
+            continue;
+        visited.add(tsconfigPath);
+        let cfg;
+        try {
+            cfg = readTsconfig(tsconfigPath);
+        }
+        catch (e) {
+            logWarn(`Skipping unreadable config: ${formatPath(tsconfigPath)}`);
+            if (verbose)
+                console.warn(e);
+            continue;
+        }
+        const outPath = join(dirname(tsconfigPath), 'tsconfig.build.json');
+        const outExists = existsSync(outPath);
+        const generatedByScript = outExists && isGeneratedByThisScript(outPath);
+        if (outExists && !generatedByScript && !force) {
+            if (verbose) {
+                logInfo(`Skip ${formatPath(outPath)} (manual file, use ${colorText('bold', '--force')})`);
+            }
+        }
+        else {
+            const written = writeBuildTsconfig(tsconfigPath, cfg, dryRun);
+            created.push({ src: tsconfigPath, out: written });
+            if (verbose || dryRun) {
+                const verb = dryRun ? colorText('yellow', '[dry-run] write') : colorText('green', 'write');
+                logInfo(`${verb} ${formatPath(written)} <- ${formatPath(tsconfigPath)}`);
+            }
+        }
+        const refs = getProjectRefs(tsconfigPath, cfg);
+        for (const r of refs)
+            queue.push(r);
+    }
+    if (!verbose && !dryRun) {
+        logInfo(`${colorText('green', 'updated')} ${created.length} tsconfig.build.json file(s)`);
+    }
+    return { created, visitedConfigs: Array.from(visited) };
+}
+function createRegenerator(entry, options) {
+    let isRunning = false;
+    let rerunRequested = false;
+    let watchedConfigs = new Set();
+    const syncWatchedConfigs = (watcher) => {
+        if (watchedConfigs.size === 0)
+            return;
+        watcher.add(Array.from(watchedConfigs));
+    };
+    const run = async (reason) => {
+        if (isRunning) {
+            rerunRequested = true;
+            return;
+        }
+        isRunning = true;
+        try {
+            do {
+                rerunRequested = false;
+                if (reason) {
+                    logInfo(`${colorText('cyan', 'regenerate')} (${reason})`);
+                    reason = undefined;
+                }
+                const result = generateBuildConfigs(entry, options);
+                watchedConfigs = new Set(result.visitedConfigs);
+            } while (rerunRequested);
+        }
+        finally {
+            isRunning = false;
+        }
+    };
+    return { run, syncWatchedConfigs };
+}
+async function main() {
+    const { values } = parseArgs({
+        args: process.argv.slice(2),
+        options: {
+            config: { type: 'string', short: 'c' },
+            dryRun: { type: 'boolean' },
+            force: { type: 'boolean' }, // overwrite files not generated by this script
+            watch: { type: 'boolean', short: 'w' },
+            verbose: { type: 'boolean', short: 'v' }
+        }
+    });
+    const entry = values.config ? resolve(values.config) : null;
+    if (!entry) {
+        logError('Missing required flag: --config <path/to/tsconfig.json>');
+        process.exit(1);
+    }
+    if (!existsSync(entry)) {
+        logError(`Config file not found: ${formatPath(entry)}`);
+        process.exit(1);
+    }
+    const dryRun = values.dryRun === true;
+    const force = values.force === true;
+    const watchMode = values.watch === true;
+    const verbose = values.verbose === true;
+    const options = { dryRun, force, verbose };
+    const regenerator = createRegenerator(entry, options);
+    await regenerator.run('initial run');
+    if (!watchMode) {
+        return;
+    }
+    logInfo(`watching ${colorText('cyan', 'tsconfig')} changes...`);
+    const watcher = watch([], {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
+    });
+    regenerator.syncWatchedConfigs(watcher);
+    watcher.on('change', async (filePath) => {
+        logInfo(`${colorText('cyan', 'change')} ${formatPath(filePath)}`);
+        await regenerator.run(`changed ${relative(process.cwd(), filePath)}`);
+        regenerator.syncWatchedConfigs(watcher);
+    });
+    watcher.on('add', async (filePath) => {
+        logInfo(`${colorText('cyan', 'add')} ${formatPath(filePath)}`);
+        await regenerator.run(`added ${relative(process.cwd(), filePath)}`);
+        regenerator.syncWatchedConfigs(watcher);
+    });
+    watcher.on('unlink', async (filePath) => {
+        logInfo(`${colorText('yellow', 'remove')} ${formatPath(filePath)}`);
+        await regenerator.run(`removed ${relative(process.cwd(), filePath)}`);
+        regenerator.syncWatchedConfigs(watcher);
+    });
+}
+main().catch((err) => {
+    logError('Unhandled error');
+    console.error(err);
+    process.exit(1);
+});

package/dist/utils/cli.d.ts

@@ -0,0 +1,2 @@
+export declare const colorText: (format: (("bgBlack" | "bgBlackBright" | "bgBlue" | "bgBlueBright" | "bgCyan" | "bgCyanBright" | "bgGray" | "bgGreen" | "bgGreenBright" | "bgGrey" | "bgMagenta" | "bgMagentaBright" | "bgRed" | "bgRedBright" | "bgWhite" | "bgWhiteBright" | "bgYellow" | "bgYellowBright") | ("black" | "blackBright" | "blue" | "blueBright" | "cyan" | "cyanBright" | "gray" | "green" | "greenBright" | "grey" | "magenta" | "magentaBright" | "red" | "redBright" | "white" | "whiteBright" | "yellow" | "yellowBright") | ("blink" | "bold" | "dim" | "doubleunderline" | "framed" | "hidden" | "inverse" | "italic" | "none" | "overlined" | "reset" | "strikethrough" | "underline"))[] | ("bgBlack" | "bgBlackBright" | "bgBlue" | "bgBlueBright" | "bgCyan" | "bgCyanBright" | "bgGray" | "bgGreen" | "bgGreenBright" | "bgGrey" | "bgMagenta" | "bgMagentaBright" | "bgRed" | "bgRedBright" | "bgWhite" | "bgWhiteBright" | "bgYellow" | "bgYellowBright") | ("black" | "blackBright" | "blue" | "blueBright" | "cyan" | "cyanBright" | "gray" | "green" | "greenBright" | "grey" | "magenta" | "magentaBright" | "red" | "redBright" | "white" | "whiteBright" | "yellow" | "yellowBright") | ("blink" | "bold" | "dim" | "doubleunderline" | "framed" | "hidden" | "inverse" | "italic" | "none" | "overlined" | "reset" | "strikethrough" | "underline"), text: unknown) => string;
+//# sourceMappingURL=cli.d.ts.map

package/dist/utils/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/utils/cli.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,ozCACsC,CAAC"}

package/dist/utils/cli.js

@@ -0,0 +1,2 @@
+import { styleText } from 'util';
+export const colorText = (format, text) => styleText(format, String(text), { validateStream: false });

package/dist/utils/index.d.ts

@@ -1,3 +1,4 @@
 export * from './browser.js';
 export * from './fs.js';
+export * from './cli.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAE7B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAE7B,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}

package/dist/utils/index.js

@@ -1,2 +1,3 @@
 export * from './browser.js';
 export * from './fs.js';
+export * from './cli.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ag",
-  "version": "1.0.19",
+  "version": "1.0.20",
   "description": "Useful TS stuff",
   "bugs": "https://github.com/ageorgeh/ts-ag/issues",
   "author": "Alexander Hornung",
@@ -10,7 +10,8 @@
   },
   "bin": {
     "clean-dist": "dist/scripts/clean-dist.js",
-    "ts-alias": "dist/scripts/ts-alias.js"
+    "ts-alias": "dist/scripts/ts-alias.js",
+    "ts-build-config": "dist/scripts/ts-build-config.js"
   },
   "files": [
     "./src",

package/src/scripts/ts-alias.ts

@@ -1,21 +1,26 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 import console from 'console';
 // NOTE: dont use aliases here cause this file needs to be compiled first
-import { existsSync, statSync, readFileSync } from 'fs';
-import { dirname, join, basename } from 'path';
+import { existsSync } from 'fs';
+import { dirname, join, basename, relative } from 'path';
 
 import type { FSWatcher } from 'chokidar';
 import { watch } from 'chokidar';
 import { glob } from 'glob';
 import { replaceTscAliasPaths } from 'tsc-alias';
 
-// Cache for tsconfig.json files
-const tsconfigCache: Map<string, { config: any; mtime: number }> = new Map();
+import { colorText } from '../utils/cli.js';
 
 // Parse command-line arguments
 const args = process.argv.slice(2);
 const watchMode = args.includes('-w') || args.includes('--watch');
+const LABEL = colorText('cyan', '[ts-alias]');
+
+const formatPath = (filePath: string): string => colorText('dim', relative(process.cwd(), filePath));
+const logInfo = (message: string): void => console.log(`${LABEL} ${message}`);
+const logWarn = (message: string): void => console.warn(`${LABEL} ${colorText('yellow', message)}`);
+const logError = (message: string): void => console.error(`${LABEL} ${colorText('red', message)}`);
 
 /**
  * Find all dist folders in the project directory, excluding certain patterns.
@@ -36,35 +41,6 @@ async function findDistFolders(baseDir: string): Promise<string[]> {
   return distFolders;
 }
 
-/**
- * Get the tsconfig.json file for a given dist folder.
- * This function caches the tsconfig file to avoid reading it multiple times.
- */
-function getTsconfig(distFolder: string): any {
-  const projectRoot = dirname(distFolder);
-  const tsconfigPath = join(projectRoot, 'tsconfig.json');
-
-  try {
-    const stats = statSync(tsconfigPath);
-    const mtime = stats.mtimeMs;
-
-    // Check cache
-    const cached = tsconfigCache.get(tsconfigPath);
-    if (cached && cached.mtime === mtime) {
-      return cached.config;
-    }
-
-    // Read and cache the config
-    const config = JSON.parse(readFileSync(tsconfigPath, 'utf8'));
-    tsconfigCache.set(tsconfigPath, { config, mtime });
-
-    return config;
-  } catch (error) {
-    console.error(`Error reading tsconfig at ${tsconfigPath}:`, error);
-    return null;
-  }
-}
-
 /**
  * Process the dist folder by replacing TypeScript alias paths with relative paths.
  */
@@ -73,22 +49,16 @@ async function processDistFolder(distFolder: string): Promise<void> {
   const tsconfigPath = join(projectRoot, 'tsconfig.json');
 
   if (!existsSync(tsconfigPath)) {
-    console.warn(`No tsconfig.json found at ${tsconfigPath}`);
-    return;
-  }
-
-  const tsconfig = getTsconfig(distFolder);
-
-  if (!tsconfig) {
-    console.warn(`Invalid tsconfig.json found for ${distFolder}`);
+    logWarn(`No tsconfig.json at ${formatPath(tsconfigPath)}`);
     return;
   }
 
   try {
     await replaceTscAliasPaths({ configFile: tsconfigPath, outDir: distFolder });
-    console.log(`Successfully processed aliases in ${distFolder}`);
+    logInfo(`${colorText('green', 'updated')} ${formatPath(distFolder)}`);
   } catch (error) {
-    console.error(`Error processing aliases in ${distFolder}:`, error);
+    logError(`Failed processing ${formatPath(distFolder)}`);
+    console.error(error);
   }
 }
 
@@ -96,7 +66,7 @@ async function processDistFolder(distFolder: string): Promise<void> {
  * Watch the dist folder for changes and process it when files are added or changed.
  */
 function watchDistFolder(distFolder: string): FSWatcher {
-  console.log(`Setting up watcher for: ${distFolder}`);
+  let pending: ReturnType<typeof setTimeout> | null = null;
 
   const watcher = watch(distFolder, {
     persistent: true,
@@ -104,17 +74,23 @@ function watchDistFolder(distFolder: string): FSWatcher {
     awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
   });
 
+  const scheduleProcess = (): void => {
+    if (pending) clearTimeout(pending);
+    pending = setTimeout(() => {
+      pending = null;
+      void processDistFolder(distFolder);
+    }, 200);
+  };
+
   watcher.on('add', (filePath) => {
     if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
-      console.log(`File added: ${filePath}`);
-      processDistFolder(distFolder);
+      scheduleProcess();
     }
   });
 
   watcher.on('change', (filePath) => {
     if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
-      console.log(`File changed: ${filePath}`);
-      processDistFolder(distFolder);
+      scheduleProcess();
     }
   });
 
@@ -124,31 +100,32 @@ function watchDistFolder(distFolder: string): FSWatcher {
 // Main function
 async function main(): Promise<void> {
   const baseDir = process.cwd();
-  console.log(`Searching for dist folders in: ${baseDir}`);
+  logInfo(`searching ${colorText('cyan', 'dist')} folders in ${formatPath(baseDir)}`);
 
   const distFolders = await findDistFolders(baseDir);
 
   // Process all folders initially if any exist
   if (distFolders.length > 0) {
-    console.log(`Found ${distFolders.length} dist folders:`);
-    distFolders.forEach((folder) => console.log(` - ${folder}`));
+    logInfo(`found ${distFolders.length} dist folder(s)`);
 
-    for (const folder of distFolders) {
-      await processDistFolder(folder);
-    }
+    await Promise.all(
+      distFolders.map(async (folder) => {
+        return await processDistFolder(folder);
+      })
+    );
   } else {
-    console.log('No dist folders found initially');
+    logInfo('no dist folders found');
   }
 
   // Set up watchers if in watch mode
   if (watchMode) {
-    console.log('Watch mode enabled, monitoring for changes...');
+    logInfo('watch mode enabled');
 
     // Set up watchers for existing dist folders
     distFolders.forEach(watchDistFolder);
 
     // Watch for new dist folders being created
-    console.log('Watching for new dist folders...');
+    logInfo('watching for new dist folders...');
     const dirWatcher = watch(baseDir, {
       persistent: true,
       ignoreInitial: true,
@@ -171,7 +148,7 @@ async function main(): Promise<void> {
       if (basename(dirPath) === 'dist') {
         // Make sure it's not already being watched
         if (!distFolders.includes(dirPath)) {
-          console.log(`New dist folder detected: ${dirPath}`);
+          logInfo(`${colorText('cyan', 'new dist')} ${formatPath(dirPath)}`);
           distFolders.push(dirPath);
           await processDistFolder(dirPath);
           watchDistFolder(dirPath);
@@ -182,6 +159,7 @@ async function main(): Promise<void> {
 }
 
 main().catch((error) => {
-  console.error('Error in ts-alias script:', error);
+  logError('Unhandled error in ts-alias script');
+  console.error(error);
   process.exit(1);
 });

package/src/scripts/ts-build-config.ts

@@ -0,0 +1,305 @@
+#!/usr/bin/env bun
+
+import console from 'console';
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'fs';
+import { dirname, join, resolve, relative } from 'path';
+import { parseArgs } from 'util';
+
+import type { FSWatcher } from 'chokidar';
+import { watch } from 'chokidar';
+import { getTsconfig } from 'get-tsconfig';
+
+import { colorText } from '../utils/cli.js';
+
+type TsConfigJson = Record<string, any>;
+
+const DEFAULT_TEST_EXCLUDES = [
+  '**/*.test.ts',
+  '**/*.test.tsx',
+  '**/*.spec.ts',
+  '**/*.spec.tsx',
+  '**/__tests__/**',
+  '**/tests/**'
+];
+const GENERATED_FILE_HEADER = '// generated by ts-build-config';
+
+const LABEL = colorText('cyan', '[ts-build-config]');
+const formatPath = (filePath: string): string => colorText('dim', relative(process.cwd(), filePath));
+const logInfo = (message: string): void => console.log(`${LABEL} ${message}`);
+const logWarn = (message: string): void => console.warn(`${LABEL} ${colorText('yellow', message)}`);
+const logError = (message: string): void => console.error(`${LABEL} ${colorText('red', message)}`);
+
+function asArray<T>(v: unknown): T[] {
+  if (!v) return [];
+  return Array.isArray(v) ? (v as T[]) : [v as T];
+}
+
+function isObject(v: unknown): v is Record<string, any> {
+  return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+
+function uniq(items: string[]): string[] {
+  return Array.from(new Set(items));
+}
+
+function normalizeRefPath(baseTsconfigPath: string, refPath: string): string {
+  // TS project references are relative to the tsconfig location
+  const baseDir = dirname(baseTsconfigPath);
+  // refPath may point to a folder (containing tsconfig.json) or a file
+  const abs = resolve(baseDir, refPath);
+  return abs;
+}
+
+function resolveReferencedTsconfigPath(refAbsPath: string): string | null {
+  // If they referenced a file directly, use it
+  if (refAbsPath.endsWith('.json')) {
+    return existsSync(refAbsPath) ? refAbsPath : null;
+  }
+
+  // Otherwise assume it's a directory containing tsconfig.json
+  const candidate = join(refAbsPath, 'tsconfig.json');
+  if (existsSync(candidate)) return candidate;
+
+  // Some repos use tsconfig.base.json or similar; we won't guess.
+  return null;
+}
+
+function readTsconfig(tsconfigPath: string): TsConfigJson {
+  const res = getTsconfig(tsconfigPath);
+  if (!res) {
+    throw new Error(`get-tsconfig could not load: ${tsconfigPath}`);
+  }
+  // get-tsconfig returns a parsed config object (includes extends resolved).
+  // We want to write a build tsconfig that extends the original file path,
+  // so we mostly only need top-level fields we change (exclude/compilerOptions).
+  return res.config as TsConfigJson;
+}
+
+function computeExtraExcludes(config: TsConfigJson): string[] {
+  const extra: string[] = [...DEFAULT_TEST_EXCLUDES];
+
+  // If the tsconfig includes ./tests (or tests) explicitly, ensure it is excluded in build config.
+  const includes = asArray<string>(config.include);
+  for (const inc of includes) {
+    const norm = inc.replace(/\\/g, '/').replace(/\/+$/, '');
+    if (norm === './tests' || norm === 'tests' || norm.startsWith('./tests/') || norm.startsWith('tests/')) {
+      extra.push('./tests/**');
+      break;
+    }
+  }
+
+  return uniq(extra);
+}
+
+function writeBuildTsconfig(tsconfigPath: string, config: TsConfigJson, dryRun: boolean): string {
+  const dir = dirname(tsconfigPath);
+  const outPath = join(dir, 'tsconfig.build.json');
+
+  const existingExclude = asArray<string>(config.exclude);
+  const mergedExclude = uniq([...existingExclude, ...computeExtraExcludes(config)]);
+
+  const buildConfig: TsConfigJson = { extends: './tsconfig.json', compilerOptions: {}, exclude: mergedExclude };
+
+  // If original compilerOptions exists, keep build-specific overrides minimal.
+  // But ensure emit is enabled if base tsconfig has noEmit: true (common for editor configs).
+  const baseCO = isObject(config.compilerOptions) ? config.compilerOptions : {};
+  if (baseCO.noEmit === true) {
+    buildConfig.compilerOptions.noEmit = false;
+  }
+
+  // Keep outDir/rootDir if already set in base; do not guess.
+  // If you want to force them, do it in the base tsconfig.json or pass flags later.
+
+  if (!dryRun) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(outPath, `${GENERATED_FILE_HEADER}\n${JSON.stringify(buildConfig, null, 2)}\n`, 'utf8');
+  }
+
+  return outPath;
+}
+
+function isGeneratedByThisScript(filePath: string): boolean {
+  try {
+    const contents = readFileSync(filePath, 'utf8');
+    const firstLine = contents.split(/\r?\n/, 1)[0]?.trim() ?? '';
+    return firstLine === GENERATED_FILE_HEADER;
+  } catch {
+    return false;
+  }
+}
+
+function getProjectRefs(tsconfigPath: string, config: TsConfigJson): string[] {
+  const refs = asArray<any>(config.references);
+  const result: string[] = [];
+
+  for (const r of refs) {
+    if (!r) continue;
+    const refPath = typeof r === 'string' ? r : r.path;
+    if (!refPath || typeof refPath !== 'string') continue;
+
+    const abs = normalizeRefPath(tsconfigPath, refPath);
+    const resolved = resolveReferencedTsconfigPath(abs);
+    if (resolved) result.push(resolved);
+  }
+
+  return uniq(result);
+}
+
+type GenerateOptions = { dryRun: boolean; force: boolean; verbose: boolean };
+
+function generateBuildConfigs(
+  entry: string,
+  options: GenerateOptions
+): { created: { src: string; out: string }[]; visitedConfigs: string[] } {
+  const { dryRun, force, verbose } = options;
+
+  const visited = new Set<string>();
+  const queue: string[] = [entry];
+  const created: { src: string; out: string }[] = [];
+
+  while (queue.length) {
+    const tsconfigPath = queue.shift()!;
+    if (visited.has(tsconfigPath)) continue;
+    visited.add(tsconfigPath);
+
+    let cfg: TsConfigJson;
+    try {
+      cfg = readTsconfig(tsconfigPath);
+    } catch (e) {
+      logWarn(`Skipping unreadable config: ${formatPath(tsconfigPath)}`);
+      if (verbose) console.warn(e);
+      continue;
+    }
+
+    const outPath = join(dirname(tsconfigPath), 'tsconfig.build.json');
+    const outExists = existsSync(outPath);
+    const generatedByScript = outExists && isGeneratedByThisScript(outPath);
+    if (outExists && !generatedByScript && !force) {
+      if (verbose) {
+        logInfo(`Skip ${formatPath(outPath)} (manual file, use ${colorText('bold', '--force')})`);
+      }
+    } else {
+      const written = writeBuildTsconfig(tsconfigPath, cfg, dryRun);
+      created.push({ src: tsconfigPath, out: written });
+      if (verbose || dryRun) {
+        const verb = dryRun ? colorText('yellow', '[dry-run] write') : colorText('green', 'write');
+        logInfo(`${verb} ${formatPath(written)} <- ${formatPath(tsconfigPath)}`);
+      }
+    }
+
+    const refs = getProjectRefs(tsconfigPath, cfg);
+    for (const r of refs) queue.push(r);
+  }
+
+  if (!verbose && !dryRun) {
+    logInfo(`${colorText('green', 'updated')} ${created.length} tsconfig.build.json file(s)`);
+  }
+
+  return { created, visitedConfigs: Array.from(visited) };
+}
+
+function createRegenerator(
+  entry: string,
+  options: GenerateOptions
+): { run: (reason?: string) => Promise<void>; syncWatchedConfigs: (watcher: FSWatcher) => void } {
+  let isRunning = false;
+  let rerunRequested = false;
+  let watchedConfigs = new Set<string>();
+
+  const syncWatchedConfigs = (watcher: FSWatcher): void => {
+    if (watchedConfigs.size === 0) return;
+    watcher.add(Array.from(watchedConfigs));
+  };
+
+  const run = async (reason?: string): Promise<void> => {
+    if (isRunning) {
+      rerunRequested = true;
+      return;
+    }
+    isRunning = true;
+
+    try {
+      do {
+        rerunRequested = false;
+        if (reason) {
+          logInfo(`${colorText('cyan', 'regenerate')} (${reason})`);
+          reason = undefined;
+        }
+        const result = generateBuildConfigs(entry, options);
+        watchedConfigs = new Set(result.visitedConfigs);
+      } while (rerunRequested);
+    } finally {
+      isRunning = false;
+    }
+  };
+
+  return { run, syncWatchedConfigs };
+}
+
+async function main(): Promise<void> {
+  const { values } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      config: { type: 'string', short: 'c' },
+      dryRun: { type: 'boolean' },
+      force: { type: 'boolean' }, // overwrite files not generated by this script
+      watch: { type: 'boolean', short: 'w' },
+      verbose: { type: 'boolean', short: 'v' }
+    }
+  });
+
+  const entry = values.config ? resolve(values.config) : null;
+  if (!entry) {
+    logError('Missing required flag: --config <path/to/tsconfig.json>');
+    process.exit(1);
+  }
+  if (!existsSync(entry)) {
+    logError(`Config file not found: ${formatPath(entry)}`);
+    process.exit(1);
+  }
+
+  const dryRun = values.dryRun === true;
+  const force = values.force === true;
+  const watchMode = values.watch === true;
+  const verbose = values.verbose === true;
+  const options: GenerateOptions = { dryRun, force, verbose };
+
+  const regenerator = createRegenerator(entry, options);
+  await regenerator.run('initial run');
+
+  if (!watchMode) {
+    return;
+  }
+
+  logInfo(`watching ${colorText('cyan', 'tsconfig')} changes...`);
+  const watcher = watch([], {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
+  });
+  regenerator.syncWatchedConfigs(watcher);
+
+  watcher.on('change', async (filePath) => {
+    logInfo(`${colorText('cyan', 'change')} ${formatPath(filePath)}`);
+    await regenerator.run(`changed ${relative(process.cwd(), filePath)}`);
+    regenerator.syncWatchedConfigs(watcher);
+  });
+
+  watcher.on('add', async (filePath) => {
+    logInfo(`${colorText('cyan', 'add')} ${formatPath(filePath)}`);
+    await regenerator.run(`added ${relative(process.cwd(), filePath)}`);
+    regenerator.syncWatchedConfigs(watcher);
+  });
+
+  watcher.on('unlink', async (filePath) => {
+    logInfo(`${colorText('yellow', 'remove')} ${formatPath(filePath)}`);
+    await regenerator.run(`removed ${relative(process.cwd(), filePath)}`);
+    regenerator.syncWatchedConfigs(watcher);
+  });
+}
+
+main().catch((err) => {
+  logError('Unhandled error');
+  console.error(err);
+  process.exit(1);
+});

package/src/utils/cli.ts

@@ -0,0 +1,4 @@
+import { styleText } from 'util';
+
+export const colorText = (format: Parameters<typeof styleText>[0], text: unknown) =>
+  styleText(format, String(text), { validateStream: false });

package/src/utils/index.ts

@@ -1,3 +1,4 @@
 export * from './browser.js';
 
 export * from './fs.js';
+export * from './cli.js';