@emeryld/rrroutes-export 1.0.8 → 1.0.9

package/README.md

@@ -66,6 +66,8 @@ Settings:
 - `--html <path>`: optional. Baked HTML viewer for changelog payload.
 - `--tsconfig <path>`: optional. TS config used for source extraction in snapshots.
 - `--with-source`: accepted for parity; changelog mode always enables source extraction.
+- `--cache-dir <path>`: optional. Directory for per-commit compile cache artifacts.
+- `--no-cache`: optional flag. Disable compile cache and force recompilation.
 
 Behavior summary:
 
@@ -73,6 +75,8 @@ Behavior summary:
 - Filters commits to those touching module tree/relevant config files.
 - Ensures tip commit is always included.
 - Creates a temp git worktree per selected commit.
+- For TypeScript module entries, compiles the commit snapshot to JS and imports emitted output.
+- For JavaScript module entries, imports directly from worktree.
 - Exports snapshots, then computes adjacent diffs:
   - route events (`route_added`, `route_removed`, `schema_changed`, `cfg_changed`)
   - source-object events (`source_object_added`, `source_object_removed`, `source_schema_changed`)
@@ -80,8 +84,15 @@ Behavior summary:
 Runtime progress logs:
 
 - `rrroutes-export-changelog` now prints step-by-step progress (window resolution, commit filtering, per-commit snapshot progress, diff totals, output writing, cleanup).
+- Changelog logs include compile lifecycle details: selected tsconfig, cache hit/miss, emitted entry path.
 - Bundle script prints stage logs for snapshot export + changelog export.
 
+Troubleshooting historical TS imports:
+
+- Changelog execution no longer relies on direct Node runtime loading of TS sources.
+- Historical imports like `./x.js` pointing to `x.ts` are handled by snapshot compilation.
+- If tsconfig auto-discovery fails, pass `--tsconfig`.
+
 ## Recommended end-to-end script
 
 Use this when you want one command to produce everything (snapshot + changelog + HTML + summary + timestamped storage).
@@ -95,6 +106,7 @@ pnpm --filter @emeryld/rrroutes-export run export:bundle -- \
   --tsconfig ./tsconfig.json \
   --from v1.4.0 \
   --to HEAD \
+  --cache-dir ./.rroutes-exports/.cache \
   --dir ./.rrroutes-exports
 ```
 
@@ -105,6 +117,8 @@ Bundle script settings (`scripts/export-release-bundle.ts`):
 - `--tsconfig <path>`: optional.
 - `--from <rev>`: optional.
 - `--to <rev>`: optional.
+- `--cache-dir <path>`: optional.
+- `--no-cache`: optional flag.
 - `--dir <path>`: optional base directory for stored bundles. Default: `.rrroutes-exports`.
 
 Per run, it writes a timestamped directory:
@@ -138,6 +152,8 @@ const changelog = await exportFinalizedLeavesChangelog({
   exportName: 'leaves',
   from: 'v1.4.0',
   to: 'HEAD',
+  cacheDir: './.cache/rrroutes-export',
+  noCache: false,
   outFile: './finalized-leaves.changelog.json',
   htmlFile: './finalized-leaves.changelog.viewer.html',
   log: (message) => console.log(message),

package/dist/exportFinalizedLeaves.changelog.cli.d.ts

@@ -6,6 +6,8 @@ export type FinalizedLeavesChangelogCliArgs = {
     tsconfigPath?: string;
     from?: string;
     to?: string;
+    cacheDir?: string;
+    noCache: boolean;
 };
 export declare function parseFinalizedLeavesChangelogCliArgs(argv: string[]): FinalizedLeavesChangelogCliArgs;
 export declare function runExportFinalizedLeavesChangelogCli(argv: string[]): Promise<{

package/dist/exportFinalizedLeaves.changelog.d.ts

@@ -115,6 +115,8 @@ export type ExportFinalizedLeavesChangelogOptions = {
     includeSource?: boolean;
     handlers?: ExportFinalizedLeavesOptions['handlers'];
     log?: (message: string) => void;
+    cacheDir?: string;
+    noCache?: boolean;
 };
 declare function resolveCommitWindow(cwd: string, from?: string, to?: string): Promise<{
     from: string;
@@ -125,6 +127,26 @@ declare function filterCommits(cwd: string, commits: string[], moduleRel: string
 declare function buildSourceIdentity(section: ChangelogSchemaSection, value: Record<string, unknown>): SourceIdentity;
 declare function toRouteSnapshots(payload: FinalizedLeavesExport): Record<string, RouteSnapshot>;
 declare function toSourceObjectSnapshots(routesByKey: Record<string, RouteSnapshot>): Record<string, SourceObjectSnapshot>;
+declare function resolveSnapshotTsconfig(worktreeDir: string, modulePath: string, tsconfigOverride?: string): Promise<string>;
+declare function toEmittedModulePath(moduleRel: string): string;
+declare function buildCompileCacheKey(commitSha: string, moduleRel: string, tsconfigPath: string, tsconfigStat: {
+    mtimeMs: number;
+    size: number;
+}): string;
+declare function compileSnapshotEntry(options: {
+    worktreeDir: string;
+    moduleRel: string;
+    modulePath: string;
+    tsconfigPath: string;
+    commitSha: string;
+    cacheRoot: string;
+    noCache?: boolean;
+    log?: (message: string) => void;
+}): Promise<string>;
+declare function loadSnapshotExport(options: {
+    entryPath: string;
+    exportName: string;
+}): Promise<{}>;
 declare function diffSnapshots(previous: CommitSnapshot, current: CommitSnapshot): {
     routeEvents: RouteChangeEvent[];
     sourceEvents: SourceObjectChangeEvent[];
@@ -138,6 +160,11 @@ export declare const __private: {
     resolveCommitWindow: typeof resolveCommitWindow;
     resolveCommitPath: typeof resolveCommitPath;
     filterCommits: typeof filterCommits;
+    resolveSnapshotTsconfig: typeof resolveSnapshotTsconfig;
+    toEmittedModulePath: typeof toEmittedModulePath;
+    buildCompileCacheKey: typeof buildCompileCacheKey;
+    compileSnapshotEntry: typeof compileSnapshotEntry;
+    loadSnapshotExport: typeof loadSnapshotExport;
     toRouteSnapshots: typeof toRouteSnapshots;
     toSourceObjectSnapshots: typeof toSourceObjectSnapshots;
     diffSnapshots: typeof diffSnapshots;

package/dist/index.cjs

@@ -1394,9 +1394,11 @@ async function runExportFinalizedLeavesCli(argv) {
 var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
+var import_node_crypto = __toESM(require("crypto"), 1);
 var import_node_child_process2 = require("child_process");
 var import_node_util = require("util");
 var import_node_url2 = require("url");
+var import_typescript2 = __toESM(require("typescript"), 1);
 var execFile = (0, import_node_util.promisify)(import_node_child_process2.execFile);
 var CHANGESET_CFG_FIELDS = [
   "summary",
@@ -1879,96 +1881,213 @@ async function pathExists(filePath) {
     return false;
   }
 }
-async function createMissingJsImportShims(worktreeDir) {
-  const shimWrites = [];
-  const filesToScan = [];
-  const skipNames = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build"]);
+function isTypeScriptModule(modulePath) {
+  const ext = import_node_path4.default.extname(modulePath).toLowerCase();
+  return ext === ".ts" || ext === ".tsx" || ext === ".mts" || ext === ".cts";
+}
+function isJavaScriptModule(modulePath) {
+  const ext = import_node_path4.default.extname(modulePath).toLowerCase();
+  return ext === ".js" || ext === ".mjs" || ext === ".cjs";
+}
+async function resolveSnapshotTsconfig(worktreeDir, modulePath, tsconfigOverride) {
+  if (tsconfigOverride) {
+    const resolved = import_node_path4.default.resolve(worktreeDir, tsconfigOverride);
+    if (!await pathExists(resolved)) {
+      throw new Error(`tsconfig not found: ${resolved}`);
+    }
+    return resolved;
+  }
+  let current = import_node_path4.default.dirname(modulePath);
+  const normalizedRoot = normalizePath(import_node_path4.default.resolve(worktreeDir));
+  while (true) {
+    const candidate = import_node_path4.default.join(current, "tsconfig.json");
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+    const parent = import_node_path4.default.dirname(current);
+    if (parent === current) break;
+    if (!normalizePath(parent).startsWith(normalizedRoot)) break;
+    current = parent;
+  }
+  throw new Error(
+    `Unable to resolve tsconfig for TypeScript module: ${modulePath}. Pass --tsconfig to override.`
+  );
+}
+function toEmittedModulePath(moduleRel) {
+  const normalized = normalizePath(moduleRel);
+  if (normalized.endsWith(".mts")) return normalized.slice(0, -4) + ".mjs";
+  if (normalized.endsWith(".cts")) return normalized.slice(0, -4) + ".cjs";
+  if (normalized.endsWith(".tsx")) return normalized.slice(0, -4) + ".js";
+  if (normalized.endsWith(".ts")) return normalized.slice(0, -3) + ".js";
+  return normalized;
+}
+function buildCompileCacheKey(commitSha, moduleRel, tsconfigPath, tsconfigStat) {
+  return import_node_crypto.default.createHash("sha1").update(commitSha).update("\n").update(normalizePath(moduleRel)).update("\n").update(normalizePath(tsconfigPath)).update("\n").update(String(tsconfigStat.mtimeMs)).update("\n").update(String(tsconfigStat.size)).digest("hex");
+}
+async function collectFilesRecursive(rootDir) {
+  const files = [];
   const walk = async (dir) => {
     const entries = await import_promises2.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
+      const target = import_node_path4.default.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (skipNames.has(entry.name)) continue;
-        await walk(import_node_path4.default.join(dir, entry.name));
+        await walk(target);
         continue;
       }
-      if (!entry.isFile()) continue;
-      if (!/\\.(ts|tsx|mts)$/.test(entry.name)) continue;
-      filesToScan.push(import_node_path4.default.join(dir, entry.name));
-    }
-  };
-  await walk(worktreeDir);
-  const importRegexes = [
-    /\\bfrom\\s+['\"](\\.[^'\"]+\\.js)['\"]/g,
-    /\\bimport\\(\\s*['\"](\\.[^'\"]+\\.js)['\"]\\s*\\)/g,
-    /\\brequire\\(\\s*['\"](\\.[^'\"]+\\.js)['\"]\\s*\\)/g
-  ];
-  const seen = /* @__PURE__ */ new Set();
-  for (const filePath of filesToScan) {
-    const content = await import_promises2.default.readFile(filePath, "utf8");
-    for (const regex of importRegexes) {
-      regex.lastIndex = 0;
-      let match = regex.exec(content);
-      while (match) {
-        const specifier = match[1];
-        const resolvedJs = import_node_path4.default.resolve(import_node_path4.default.dirname(filePath), specifier);
-        if (seen.has(resolvedJs)) {
-          match = regex.exec(content);
-          continue;
-        }
-        seen.add(resolvedJs);
-        if (await pathExists(resolvedJs)) {
-          match = regex.exec(content);
-          continue;
-        }
-        const tsCandidates = [
-          resolvedJs.replace(/\\.js$/, ".ts"),
-          resolvedJs.replace(/\\.js$/, ".mts"),
-          resolvedJs.replace(/\\.js$/, ".tsx")
-        ];
-        let targetTs;
-        for (const candidate of tsCandidates) {
-          if (await pathExists(candidate)) {
-            targetTs = candidate;
-            break;
-          }
-        }
-        if (targetTs) {
-          const relImport = normalizePath(import_node_path4.default.relative(import_node_path4.default.dirname(resolvedJs), targetTs));
-          const importPath = relImport.startsWith(".") ? relImport : `./${relImport}`;
-          const shim = `export * from '${importPath}'
-import * as __all from '${importPath}'
-export default ('default' in __all ? __all.default : __all)
-`;
-          await import_promises2.default.mkdir(import_node_path4.default.dirname(resolvedJs), { recursive: true });
-          await import_promises2.default.writeFile(resolvedJs, shim, "utf8");
-          shimWrites.push(resolvedJs);
-        }
-        match = regex.exec(content);
+      if (entry.isFile()) {
+        files.push(target);
       }
     }
+  };
+  if (await pathExists(rootDir)) {
+    await walk(rootDir);
   }
-  return shimWrites;
+  return files;
+}
+function suffixMatchScore(candidate, wanted) {
+  const left = normalizePath(candidate).split("/");
+  const right = normalizePath(wanted).split("/");
+  let score = 0;
+  while (score < left.length && score < right.length) {
+    const a = left[left.length - 1 - score];
+    const b = right[right.length - 1 - score];
+    if (a !== b) break;
+    score += 1;
+  }
+  return score;
+}
+async function resolveEmittedEntryPath(emitRoot, moduleRel) {
+  const expected = import_node_path4.default.resolve(emitRoot, toEmittedModulePath(moduleRel));
+  if (await pathExists(expected)) {
+    return expected;
+  }
+  const wantedRel = toEmittedModulePath(moduleRel);
+  const wantedBase = import_node_path4.default.posix.basename(normalizePath(wantedRel));
+  const files = await collectFilesRecursive(emitRoot);
+  const candidates = files.filter(
+    (file) => import_node_path4.default.posix.basename(normalizePath(file)) === wantedBase
+  );
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  candidates.sort(
+    (a, b) => suffixMatchScore(b, wantedRel) - suffixMatchScore(a, wantedRel)
+  );
+  return candidates[0];
+}
+async function compileSnapshotEntry(options) {
+  const log = options.log ?? (() => void 0);
+  const tsconfigStat = await import_promises2.default.stat(options.tsconfigPath);
+  const cacheKey = buildCompileCacheKey(
+    options.commitSha,
+    options.moduleRel,
+    options.tsconfigPath,
+    { mtimeMs: tsconfigStat.mtimeMs, size: tsconfigStat.size }
+  );
+  const emitRoot = import_node_path4.default.join(options.cacheRoot, cacheKey, "dist");
+  let emittedEntry = import_node_path4.default.resolve(emitRoot, toEmittedModulePath(options.moduleRel));
+  if (!options.noCache && await pathExists(emittedEntry)) {
+    log(`[changelog] compile cache hit: ${options.commitSha.slice(0, 12)}`);
+    return emittedEntry;
+  }
+  log(
+    `[changelog] compile cache ${options.noCache ? "disabled" : "miss"}: ${options.commitSha.slice(0, 12)}`
+  );
+  await import_promises2.default.rm(import_node_path4.default.join(options.cacheRoot, cacheKey), { recursive: true, force: true }).catch(
+    () => void 0
+  );
+  await import_promises2.default.mkdir(emitRoot, { recursive: true });
+  const readResult = import_typescript2.default.readConfigFile(options.tsconfigPath, import_typescript2.default.sys.readFile);
+  if (readResult.error) {
+    throw new Error(import_typescript2.default.flattenDiagnosticMessageText(readResult.error.messageText, "\n"));
+  }
+  const parsed = import_typescript2.default.parseJsonConfigFileContent(
+    readResult.config,
+    import_typescript2.default.sys,
+    import_node_path4.default.dirname(options.tsconfigPath)
+  );
+  const compilerOptions = {
+    ...parsed.options,
+    noEmit: false,
+    declaration: false,
+    declarationMap: false,
+    sourceMap: false,
+    inlineSourceMap: false,
+    composite: false,
+    incremental: false,
+    tsBuildInfoFile: void 0,
+    outDir: emitRoot
+  };
+  const program = import_typescript2.default.createProgram([options.modulePath], compilerOptions);
+  const emitResult = program.emit();
+  const diagnostics = import_typescript2.default.getPreEmitDiagnostics(program).concat(emitResult.diagnostics).filter((diagnostic) => diagnostic.category === import_typescript2.default.DiagnosticCategory.Error);
+  if (diagnostics.length > 0) {
+    const host = {
+      getCanonicalFileName: (fileName) => fileName,
+      getCurrentDirectory: () => options.worktreeDir,
+      getNewLine: () => "\n"
+    };
+    const message = import_typescript2.default.formatDiagnosticsWithColorAndContext(diagnostics.slice(0, 20), host);
+    throw new Error(
+      `TypeScript snapshot compile failed for ${options.moduleRel} at ${options.commitSha.slice(0, 12)}:
+${message}`
+    );
+  }
+  emittedEntry = await resolveEmittedEntryPath(emitRoot, options.moduleRel) ?? emittedEntry;
+  if (!await pathExists(emittedEntry)) {
+    throw new Error(
+      `Compiled snapshot entry was not emitted: ${emittedEntry}. Check module/tsconfig compatibility.`
+    );
+  }
+  log(`[changelog] compiled snapshot entry: ${emittedEntry}`);
+  return emittedEntry;
+}
+async function loadSnapshotExport(options) {
+  return loadChangelogInput(options.entryPath, options.exportName);
 }
 async function createSnapshot(repoRoot, moduleRel, exportName, commit, tempRoot, tsconfigRel, exportOptions, log) {
   const worktreeDir = import_node_path4.default.join(tempRoot, `wt-${commit.sha.slice(0, 12)}`);
   await runGit(repoRoot, ["worktree", "add", "--detach", worktreeDir, commit.sha]);
   try {
     await ensureWorktreeDependencies(repoRoot, worktreeDir);
-    const shimmedFiles = await createMissingJsImportShims(worktreeDir);
-    if (shimmedFiles.length > 0) {
-      log?.(
-        `[changelog] created ${shimmedFiles.length} missing .js import shim(s) in ${commit.sha.slice(0, 12)}`
+    const modulePath = import_node_path4.default.resolve(worktreeDir, moduleRel);
+    let snapshotRuntimePath = modulePath;
+    let resolvedTsconfigPath;
+    if (isTypeScriptModule(modulePath)) {
+      resolvedTsconfigPath = await resolveSnapshotTsconfig(
+        worktreeDir,
+        modulePath,
+        tsconfigRel
+      );
+      log?.(`[changelog] using tsconfig: ${resolvedTsconfigPath}`);
+      const compileCacheRoot = import_node_path4.default.resolve(
+        exportOptions?.cacheDir ?? import_node_path4.default.join(import_node_os.default.tmpdir(), "rrroutes-export-changelog-cache")
+      );
+      snapshotRuntimePath = await compileSnapshotEntry({
+        worktreeDir,
+        moduleRel,
+        modulePath,
+        tsconfigPath: resolvedTsconfigPath,
+        commitSha: commit.sha,
+        cacheRoot: compileCacheRoot,
+        noCache: exportOptions?.noCache,
+        log
+      });
+    } else if (!isJavaScriptModule(modulePath)) {
+      throw new Error(
+        `Unsupported module extension for changelog snapshots: ${modulePath}`
       );
     }
-    const modulePath = import_node_path4.default.resolve(worktreeDir, moduleRel);
-    const tsconfigPath = tsconfigRel ? import_node_path4.default.resolve(worktreeDir, tsconfigRel) : void 0;
-    const input = await loadChangelogInput(modulePath, exportName);
+    const input = await loadSnapshotExport({
+      entryPath: snapshotRuntimePath,
+      exportName
+    });
     const payload = await exportFinalizedLeaves(input, {
       includeSource: true,
       sourceModulePath: modulePath,
       sourceExportName: exportName,
-      tsconfigPath,
-      ...exportOptions
+      tsconfigPath: resolvedTsconfigPath ?? (tsconfigRel ? import_node_path4.default.resolve(worktreeDir, tsconfigRel) : void 0),
+      handlers: exportOptions?.handlers
     });
     const routesByKey = toRouteSnapshots(payload);
     const sourceObjectsById = toSourceObjectSnapshots(routesByKey);
@@ -2293,6 +2412,11 @@ var __private = {
   resolveCommitWindow,
   resolveCommitPath,
   filterCommits,
+  resolveSnapshotTsconfig,
+  toEmittedModulePath,
+  buildCompileCacheKey,
+  compileSnapshotEntry,
+  loadSnapshotExport,
   toRouteSnapshots,
   toSourceObjectSnapshots,
   diffSnapshots,
@@ -2303,6 +2427,7 @@ var __private = {
 var import_node_path5 = __toESM(require("path"), 1);
 function parseFinalizedLeavesChangelogCliArgs(argv) {
   const args = /* @__PURE__ */ new Map();
+  let noCache = false;
   for (let i = 0; i < argv.length; i += 1) {
     const key = argv[i];
     if (key === "--") continue;
@@ -2310,6 +2435,10 @@ function parseFinalizedLeavesChangelogCliArgs(argv) {
     if (key === "--with-source") {
       continue;
     }
+    if (key === "--no-cache") {
+      noCache = true;
+      continue;
+    }
     const value = argv[i + 1];
     if (!value || value.startsWith("--")) {
       throw new Error(`Missing value for ${key}`);
@@ -2328,7 +2457,9 @@ function parseFinalizedLeavesChangelogCliArgs(argv) {
     htmlFile: args.get("--html") ?? void 0,
     tsconfigPath: args.get("--tsconfig") ?? void 0,
     from: args.get("--from") ?? void 0,
-    to: args.get("--to") ?? void 0
+    to: args.get("--to") ?? void 0,
+    cacheDir: args.get("--cache-dir") ?? void 0,
+    noCache
   };
 }
 async function runExportFinalizedLeavesChangelogCli(argv) {
@@ -2346,6 +2477,8 @@ async function runExportFinalizedLeavesChangelogCli(argv) {
     from: args.from,
     to: args.to,
     includeSource: true,
+    cacheDir: args.cacheDir,
+    noCache: args.noCache,
     log
   };
   log("[changelog-cli] starting changelog export");