ts-ag 1.0.20 → 1.0.22

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

@@ -5,6 +5,7 @@ import { dirname, join, resolve, relative } from 'path';
 import { parseArgs } from 'util';
 import { watch } from 'chokidar';
 import { getTsconfig } from 'get-tsconfig';
+import { format as formatWithOxfmt } from 'oxfmt';
 import { colorText } from '../utils/cli.js';
 const DEFAULT_TEST_EXCLUDES = [
     '**/*.test.ts',
@@ -73,12 +74,42 @@ function computeExtraExcludes(config) {
     }
     return uniq(extra);
 }
-function writeBuildTsconfig(tsconfigPath, config, dryRun) {
+function withTrailingNewline(value) {
+    return value.endsWith('\n') ? value : `${value}\n`;
+}
+async function formatBuildTsconfigJson(config) {
+    const fallback = JSON.stringify(config, null, 2);
+    try {
+        const result = await formatWithOxfmt('tsconfig.build.json', fallback, {
+            useTabs: false,
+            singleQuote: true,
+            trailingComma: 'none',
+            printWidth: 120,
+            objectWrap: 'collapse',
+            semi: true,
+            proseWrap: 'always',
+            sortPackageJson: { sortScripts: true },
+            sortImports: {}
+        });
+        if (!result.errors.length && typeof result.code === 'string' && result.code.length > 0) {
+            return withTrailingNewline(result.code);
+        }
+    }
+    catch {
+        // Fallback to plain JSON below.
+    }
+    return withTrailingNewline(fallback);
+}
+async 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 };
+    const refs = asArray(config.references);
+    if (refs.length > 0) {
+        buildConfig.references = refs;
+    }
     // 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 : {};
@@ -89,7 +120,8 @@ function writeBuildTsconfig(tsconfigPath, config, dryRun) {
     // 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');
+        const formattedJson = await formatBuildTsconfigJson(buildConfig);
+        writeFileSync(outPath, `${GENERATED_FILE_HEADER}\n${formattedJson}`, 'utf8');
     }
     return outPath;
 }
@@ -119,11 +151,62 @@ function getProjectRefs(tsconfigPath, config) {
     }
     return uniq(result);
 }
-function generateBuildConfigs(entry, options) {
+function shouldUseBuildConfig(tsconfigPath, force) {
+    const outPath = join(dirname(tsconfigPath), 'tsconfig.build.json');
+    if (!existsSync(outPath))
+        return true;
+    if (force)
+        return true;
+    return isGeneratedByThisScript(outPath);
+}
+function asPosixPath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+function ensureDotRelative(filePath) {
+    if (filePath.startsWith('.'))
+        return filePath;
+    return `./${filePath}`;
+}
+function replaceRefsWithBuildConfigs(tsconfigPath, config, buildConfigSet) {
+    const refs = asArray(config.references);
+    if (refs.length === 0)
+        return config;
+    const baseDir = dirname(tsconfigPath);
+    const mapped = refs.map((refEntry) => {
+        if (!refEntry)
+            return refEntry;
+        const refPath = typeof refEntry === 'string' ? refEntry : refEntry.path;
+        if (!refPath || typeof refPath !== 'string')
+            return refEntry;
+        const normalizedRefPath = ensureDotRelative(asPosixPath(refPath));
+        const abs = normalizeRefPath(tsconfigPath, refPath);
+        const resolvedRefTsconfig = resolveReferencedTsconfigPath(abs);
+        if (!resolvedRefTsconfig) {
+            if (typeof refEntry === 'string')
+                return normalizedRefPath;
+            return { ...refEntry, path: normalizedRefPath };
+        }
+        if (!buildConfigSet.has(resolvedRefTsconfig)) {
+            if (typeof refEntry === 'string')
+                return normalizedRefPath;
+            return { ...refEntry, path: normalizedRefPath };
+        }
+        const buildRefPath = join(dirname(resolvedRefTsconfig), 'tsconfig.build.json');
+        const relativeBuildRef = ensureDotRelative(asPosixPath(relative(baseDir, buildRefPath)));
+        if (typeof refEntry === 'string') {
+            return relativeBuildRef;
+        }
+        return { ...refEntry, path: relativeBuildRef };
+    });
+    return { ...config, references: mapped };
+}
+async function generateBuildConfigs(entry, options) {
     const { dryRun, force, verbose } = options;
+    const loadedConfigs = new Map();
     const visited = new Set();
     const queue = [entry];
     const created = [];
+    // First pass: discover the full referenced tsconfig graph and load configs.
     while (queue.length) {
         const tsconfigPath = queue.shift();
         if (visited.has(tsconfigPath))
@@ -139,25 +222,31 @@ function generateBuildConfigs(entry, options) {
                 console.warn(e);
             continue;
         }
+        loadedConfigs.set(tsconfigPath, cfg);
+        const refs = getProjectRefs(tsconfigPath, cfg);
+        for (const r of refs)
+            queue.push(r);
+    }
+    const discoveredConfigs = Array.from(visited).filter((path) => loadedConfigs.has(path));
+    const buildConfigSet = new Set(discoveredConfigs.filter((path) => shouldUseBuildConfig(path, force)));
+    // Second pass: write build configs with rewritten references.
+    for (const tsconfigPath of discoveredConfigs) {
+        const cfg = loadedConfigs.get(tsconfigPath);
         const outPath = join(dirname(tsconfigPath), 'tsconfig.build.json');
-        const outExists = existsSync(outPath);
-        const generatedByScript = outExists && isGeneratedByThisScript(outPath);
-        if (outExists && !generatedByScript && !force) {
+        if (!buildConfigSet.has(tsconfigPath)) {
             if (verbose) {
                 logInfo(`Skip ${formatPath(outPath)} (manual file, use ${colorText('bold', '--force')})`);
             }
         }
         else {
-            const written = writeBuildTsconfig(tsconfigPath, cfg, dryRun);
+            const rewrittenCfg = replaceRefsWithBuildConfigs(tsconfigPath, cfg, buildConfigSet);
+            const written = await writeBuildTsconfig(tsconfigPath, rewrittenCfg, 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)`);
@@ -186,7 +275,7 @@ function createRegenerator(entry, options) {
                     logInfo(`${colorText('cyan', 'regenerate')} (${reason})`);
                     reason = undefined;
                 }
-                const result = generateBuildConfigs(entry, options);
+                const result = await generateBuildConfigs(entry, options);
                 watchedConfigs = new Set(result.visitedConfigs);
             } while (rerunRequested);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ag",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "Useful TS stuff",
   "bugs": "https://github.com/ageorgeh/ts-ag/issues",
   "author": "Alexander Hornung",
@@ -68,7 +68,7 @@
   "devDependencies": {
     "@actions/languageserver": "^0.3.46",
     "@types/hast": "3.0.4",
-    "@types/node": "^24.10.15",
+    "@types/node": "^24.11.0",
     "@types/ungap__structured-clone": "1.2.0",
     "@typescript/native-preview": "7.0.0-dev.20260227.1",
     "concurrently": "^9.2.1",

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

@@ -8,9 +8,12 @@ import { parseArgs } from 'util';
 import type { FSWatcher } from 'chokidar';
 import { watch } from 'chokidar';
 import { getTsconfig } from 'get-tsconfig';
+import { format as formatWithOxfmt } from 'oxfmt';
 
 import { colorText } from '../utils/cli.js';
 
+// TODO on startup check cwd for oxfmt config and use that instead of my default
+
 type TsConfigJson = Record<string, any>;
 
 const DEFAULT_TEST_EXCLUDES = [
@@ -91,7 +94,36 @@ function computeExtraExcludes(config: TsConfigJson): string[] {
   return uniq(extra);
 }
 
-function writeBuildTsconfig(tsconfigPath: string, config: TsConfigJson, dryRun: boolean): string {
+function withTrailingNewline(value: string): string {
+  return value.endsWith('\n') ? value : `${value}\n`;
+}
+
+async function formatBuildTsconfigJson(config: TsConfigJson): Promise<string> {
+  const fallback = JSON.stringify(config, null, 2);
+
+  try {
+    const result = await formatWithOxfmt('tsconfig.build.json', fallback, {
+      useTabs: false,
+      singleQuote: true,
+      trailingComma: 'none',
+      printWidth: 120,
+      objectWrap: 'collapse',
+      semi: true,
+      proseWrap: 'always',
+      sortPackageJson: { sortScripts: true },
+      sortImports: {}
+    });
+    if (!result.errors.length && typeof result.code === 'string' && result.code.length > 0) {
+      return withTrailingNewline(result.code);
+    }
+  } catch {
+    // Fallback to plain JSON below.
+  }
+
+  return withTrailingNewline(fallback);
+}
+
+async function writeBuildTsconfig(tsconfigPath: string, config: TsConfigJson, dryRun: boolean): Promise<string> {
   const dir = dirname(tsconfigPath);
   const outPath = join(dir, 'tsconfig.build.json');
 
@@ -99,6 +131,10 @@ function writeBuildTsconfig(tsconfigPath: string, config: TsConfigJson, dryRun:
   const mergedExclude = uniq([...existingExclude, ...computeExtraExcludes(config)]);
 
   const buildConfig: TsConfigJson = { extends: './tsconfig.json', compilerOptions: {}, exclude: mergedExclude };
+  const refs = asArray<unknown>(config.references);
+  if (refs.length > 0) {
+    buildConfig.references = refs;
+  }
 
   // If original compilerOptions exists, keep build-specific overrides minimal.
   // But ensure emit is enabled if base tsconfig has noEmit: true (common for editor configs).
@@ -112,7 +148,8 @@ function writeBuildTsconfig(tsconfigPath: string, config: TsConfigJson, dryRun:
 
   if (!dryRun) {
     mkdirSync(dir, { recursive: true });
-    writeFileSync(outPath, `${GENERATED_FILE_HEADER}\n${JSON.stringify(buildConfig, null, 2)}\n`, 'utf8');
+    const formattedJson = await formatBuildTsconfigJson(buildConfig);
+    writeFileSync(outPath, `${GENERATED_FILE_HEADER}\n${formattedJson}`, 'utf8');
   }
 
   return outPath;
@@ -145,18 +182,76 @@ function getProjectRefs(tsconfigPath: string, config: TsConfigJson): string[] {
   return uniq(result);
 }
 
+function shouldUseBuildConfig(tsconfigPath: string, force: boolean): boolean {
+  const outPath = join(dirname(tsconfigPath), 'tsconfig.build.json');
+  if (!existsSync(outPath)) return true;
+  if (force) return true;
+  return isGeneratedByThisScript(outPath);
+}
+
+function asPosixPath(filePath: string): string {
+  return filePath.replace(/\\/g, '/');
+}
+
+function ensureDotRelative(filePath: string): string {
+  if (filePath.startsWith('.')) return filePath;
+  return `./${filePath}`;
+}
+
+function replaceRefsWithBuildConfigs(
+  tsconfigPath: string,
+  config: TsConfigJson,
+  buildConfigSet: Set<string>
+): TsConfigJson {
+  const refs = asArray<any>(config.references);
+  if (refs.length === 0) return config;
+
+  const baseDir = dirname(tsconfigPath);
+  const mapped = refs.map((refEntry) => {
+    if (!refEntry) return refEntry;
+
+    const refPath = typeof refEntry === 'string' ? refEntry : refEntry.path;
+    if (!refPath || typeof refPath !== 'string') return refEntry;
+
+    const normalizedRefPath = ensureDotRelative(asPosixPath(refPath));
+    const abs = normalizeRefPath(tsconfigPath, refPath);
+    const resolvedRefTsconfig = resolveReferencedTsconfigPath(abs);
+    if (!resolvedRefTsconfig) {
+      if (typeof refEntry === 'string') return normalizedRefPath;
+      return { ...refEntry, path: normalizedRefPath };
+    }
+    if (!buildConfigSet.has(resolvedRefTsconfig)) {
+      if (typeof refEntry === 'string') return normalizedRefPath;
+      return { ...refEntry, path: normalizedRefPath };
+    }
+
+    const buildRefPath = join(dirname(resolvedRefTsconfig), 'tsconfig.build.json');
+    const relativeBuildRef = ensureDotRelative(asPosixPath(relative(baseDir, buildRefPath)));
+
+    if (typeof refEntry === 'string') {
+      return relativeBuildRef;
+    }
+
+    return { ...refEntry, path: relativeBuildRef };
+  });
+
+  return { ...config, references: mapped };
+}
+
 type GenerateOptions = { dryRun: boolean; force: boolean; verbose: boolean };
 
-function generateBuildConfigs(
+async function generateBuildConfigs(
   entry: string,
   options: GenerateOptions
-): { created: { src: string; out: string }[]; visitedConfigs: string[] } {
+): Promise<{ created: { src: string; out: string }[]; visitedConfigs: string[] }> {
   const { dryRun, force, verbose } = options;
 
+  const loadedConfigs = new Map<string, TsConfigJson>();
   const visited = new Set<string>();
   const queue: string[] = [entry];
   const created: { src: string; out: string }[] = [];
 
+  // First pass: discover the full referenced tsconfig graph and load configs.
   while (queue.length) {
     const tsconfigPath = queue.shift()!;
     if (visited.has(tsconfigPath)) continue;
@@ -170,25 +265,32 @@ function generateBuildConfigs(
       if (verbose) console.warn(e);
       continue;
     }
+    loadedConfigs.set(tsconfigPath, cfg);
+
+    const refs = getProjectRefs(tsconfigPath, cfg);
+    for (const r of refs) queue.push(r);
+  }
+
+  const discoveredConfigs = Array.from(visited).filter((path) => loadedConfigs.has(path));
+  const buildConfigSet = new Set(discoveredConfigs.filter((path) => shouldUseBuildConfig(path, force)));
 
+  // Second pass: write build configs with rewritten references.
+  for (const tsconfigPath of discoveredConfigs) {
+    const cfg = loadedConfigs.get(tsconfigPath)!;
     const outPath = join(dirname(tsconfigPath), 'tsconfig.build.json');
-    const outExists = existsSync(outPath);
-    const generatedByScript = outExists && isGeneratedByThisScript(outPath);
-    if (outExists && !generatedByScript && !force) {
+    if (!buildConfigSet.has(tsconfigPath)) {
       if (verbose) {
         logInfo(`Skip ${formatPath(outPath)} (manual file, use ${colorText('bold', '--force')})`);
       }
     } else {
-      const written = writeBuildTsconfig(tsconfigPath, cfg, dryRun);
+      const rewrittenCfg = replaceRefsWithBuildConfigs(tsconfigPath, cfg, buildConfigSet);
+      const written = await writeBuildTsconfig(tsconfigPath, rewrittenCfg, 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) {
@@ -225,7 +327,7 @@ function createRegenerator(
           logInfo(`${colorText('cyan', 'regenerate')} (${reason})`);
           reason = undefined;
         }
-        const result = generateBuildConfigs(entry, options);
+        const result = await generateBuildConfigs(entry, options);
         watchedConfigs = new Set(result.visitedConfigs);
       } while (rerunRequested);
     } finally {