@emeryld/rrroutes-export 1.0.9 → 1.0.10

package/README.md

@@ -72,11 +72,13 @@ Settings:
 Behavior summary:
 
 - Resolves commit path from `from..to` (chronological).
+- Builds commit-aware module path candidates (current path + extension variants + rename history).
 - 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.
+- If module entrypoint cannot be resolved for a commit, changelog uses an empty snapshot for that commit (timeline continuity).
 - 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`)
@@ -85,6 +87,7 @@ 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.
+- Changelog logs include per-commit module resolution and unresolved-entry fallback messages.
 - Bundle script prints stage logs for snapshot export + changelog export.
 
 Troubleshooting historical TS imports:
@@ -92,6 +95,7 @@ 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`.
+- If entrypoint path moved across history, changelog resolves rename history automatically.
 
 ## Recommended end-to-end script
 

package/dist/exportFinalizedLeaves.changelog.d.ts

@@ -32,6 +32,7 @@ type CommitSnapshot = {
     commit: ChangelogCommit;
     routesByKey: Record<string, RouteSnapshot>;
     sourceObjectsById: Record<string, SourceObjectSnapshot>;
+    unresolvedModule?: boolean;
 };
 type DiffOp = 'added' | 'removed' | 'changed';
 export type SchemaPathDelta = {
@@ -96,6 +97,7 @@ export type FinalizedLeavesChangelogExport = {
         from: string;
         to: string;
         selectedCommitCount: number;
+        unresolvedModuleCommits?: string[];
     };
     commits: ChangelogCommit[];
     byRoute: Record<string, RouteChangeEvent[]>;
@@ -123,7 +125,9 @@ declare function resolveCommitWindow(cwd: string, from?: string, to?: string): P
     to: string;
 }>;
 declare function resolveCommitPath(cwd: string, fromCommit: string, toCommit: string): Promise<string[]>;
-declare function filterCommits(cwd: string, commits: string[], moduleRel: string, tsconfigRel?: string): Promise<string[]>;
+declare function buildModulePathCandidates(repoRoot: string, toCommit: string, requestedModuleRel: string): Promise<string[]>;
+declare function resolveModulePathForCommit(repoRoot: string, commitSha: string, candidates: readonly string[]): Promise<string | undefined>;
+declare function filterCommits(cwd: string, commits: string[], moduleCandidates: readonly string[], tsconfigRel?: string): Promise<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>;
@@ -160,6 +164,8 @@ export declare const __private: {
     resolveCommitWindow: typeof resolveCommitWindow;
     resolveCommitPath: typeof resolveCommitPath;
     filterCommits: typeof filterCommits;
+    buildModulePathCandidates: typeof buildModulePathCandidates;
+    resolveModulePathForCommit: typeof resolveModulePathForCommit;
     resolveSnapshotTsconfig: typeof resolveSnapshotTsconfig;
     toEmittedModulePath: typeof toEmittedModulePath;
     buildCompileCacheKey: typeof buildCompileCacheKey;

package/dist/index.cjs

@@ -1411,6 +1411,7 @@ var CHANGESET_CFG_FIELDS = [
   "feed"
 ];
 var SCHEMA_SECTIONS = ["params", "query", "body", "output"];
+var MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs"];
 var SOURCE_KEY_BY_SECTION = {
   params: "paramsSchema",
   query: "querySchema",
@@ -1525,6 +1526,65 @@ async function resolveCommitPath(cwd, fromCommit, toCommit) {
   const commits = pathRaw.split("\n").map((item) => item.trim()).filter(Boolean);
   return [fromCommit, ...commits];
 }
+function modulePathStem(modulePath) {
+  const normalized = normalizePath(modulePath).replace(/^\/+/, "");
+  for (const ext of MODULE_EXTENSIONS) {
+    if (normalized.endsWith(ext)) {
+      return normalized.slice(0, -ext.length);
+    }
+  }
+  return normalized;
+}
+function extensionVariants(pathLike) {
+  const stem = modulePathStem(pathLike);
+  return MODULE_EXTENSIONS.map((ext) => `${stem}${ext}`);
+}
+async function buildModulePathCandidates(repoRoot, toCommit, requestedModuleRel) {
+  const requested = normalizePath(requestedModuleRel).replace(/^\/+/, "");
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushCandidate = (value) => {
+    const normalized = normalizePath(value).replace(/^\/+/, "");
+    if (!normalized) return;
+    if (seen.has(normalized)) return;
+    seen.add(normalized);
+    out.push(normalized);
+  };
+  pushCandidate(requested);
+  extensionVariants(requested).forEach(pushCandidate);
+  const history = await runGit(repoRoot, [
+    "log",
+    "--follow",
+    "--name-only",
+    "--format=",
+    toCommit,
+    "--",
+    requested
+  ]);
+  history.split("\n").map((item) => item.trim()).filter(Boolean).forEach((candidate) => {
+    pushCandidate(candidate);
+    extensionVariants(candidate).forEach(pushCandidate);
+  });
+  return out;
+}
+async function commitHasPath(repoRoot, commitSha, candidatePath) {
+  try {
+    await execFile("git", ["cat-file", "-e", `${commitSha}:${candidatePath}`], {
+      cwd: repoRoot
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveModulePathForCommit(repoRoot, commitSha, candidates) {
+  for (const candidate of candidates) {
+    if (await commitHasPath(repoRoot, commitSha, candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
 function parentDirectories(relativePath) {
   const clean = normalizePath(relativePath).replace(/^\/+/, "");
   const dir = import_node_path4.default.posix.dirname(clean);
@@ -1536,8 +1596,11 @@ function parentDirectories(relativePath) {
   }
   return out;
 }
-function buildRelevantConfigFiles(moduleRel, tsconfigRel) {
-  const dirs = new Set(parentDirectories(moduleRel));
+function buildRelevantConfigFiles(moduleCandidates, tsconfigRel) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const moduleRel of moduleCandidates) {
+    parentDirectories(moduleRel).forEach((item) => dirs.add(item));
+  }
   if (tsconfigRel) {
     parentDirectories(tsconfigRel).forEach((item) => dirs.add(item));
     dirs.add(import_node_path4.default.posix.dirname(normalizePath(tsconfigRel)));
@@ -1550,7 +1613,7 @@ function buildRelevantConfigFiles(moduleRel, tsconfigRel) {
   }
   return files;
 }
-async function commitTouchedRelevantPaths(cwd, commit, moduleRel, tsconfigRel) {
+async function commitTouchedRelevantPaths(cwd, commit, moduleCandidates, tsconfigRel) {
   const changed = await runGit(cwd, [
     "show",
     "--pretty=format:",
@@ -1559,27 +1622,35 @@ async function commitTouchedRelevantPaths(cwd, commit, moduleRel, tsconfigRel) {
     commit
   ]);
   const changedFiles = changed.split("\n").map((item) => normalizePath(item.trim()).replace(/^\/+/, "")).filter(Boolean);
-  const moduleFile = normalizePath(moduleRel).replace(/^\/+/, "");
-  const moduleDir = normalizePath(import_node_path4.default.posix.dirname(moduleFile)).replace(/^\/+/, "");
+  const moduleFiles = Array.from(
+    new Set(moduleCandidates.map((item) => normalizePath(item).replace(/^\/+/, "")))
+  );
+  const moduleDirs = Array.from(
+    new Set(
+      moduleFiles.map((item) => normalizePath(import_node_path4.default.posix.dirname(item)).replace(/^\/+/, "")).filter((item) => item && item !== ".")
+    )
+  );
   const tsconfigFile = tsconfigRel ? normalizePath(tsconfigRel).replace(/^\/+/, "") : void 0;
-  const configFiles = buildRelevantConfigFiles(moduleFile, tsconfigFile);
+  const configFiles = buildRelevantConfigFiles(moduleFiles, tsconfigFile);
   return changedFiles.some((file) => {
-    if (file === moduleFile) return true;
-    if (moduleDir && moduleDir !== "." && (file === moduleDir || file.startsWith(`${moduleDir}/`))) {
-      return true;
+    if (moduleFiles.includes(file)) return true;
+    for (const moduleDir of moduleDirs) {
+      if (file === moduleDir || file.startsWith(`${moduleDir}/`)) {
+        return true;
+      }
     }
     if (tsconfigFile && file === tsconfigFile) return true;
     return configFiles.has(file);
   });
 }
-async function filterCommits(cwd, commits, moduleRel, tsconfigRel) {
+async function filterCommits(cwd, commits, moduleCandidates, tsconfigRel) {
   if (commits.length <= 1) {
     return commits;
   }
   const keep = [commits[0]];
   for (let i = 1; i < commits.length; i += 1) {
     const commit = commits[i];
-    if (await commitTouchedRelevantPaths(cwd, commit, moduleRel, tsconfigRel)) {
+    if (await commitTouchedRelevantPaths(cwd, commit, moduleCandidates, tsconfigRel)) {
       keep.push(commit);
     }
   }
@@ -2045,12 +2116,31 @@ ${message}`
 async function loadSnapshotExport(options) {
   return loadChangelogInput(options.entryPath, options.exportName);
 }
-async function createSnapshot(repoRoot, moduleRel, exportName, commit, tempRoot, tsconfigRel, exportOptions, log) {
+async function createSnapshot(repoRoot, moduleCandidates, 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 modulePath = import_node_path4.default.resolve(worktreeDir, moduleRel);
+    const resolvedModuleRel = await resolveModulePathForCommit(
+      repoRoot,
+      commit.sha,
+      moduleCandidates
+    );
+    if (!resolvedModuleRel) {
+      log?.(
+        `[changelog] unresolved module for commit ${commit.sha.slice(0, 12)}; using empty snapshot`
+      );
+      return {
+        commit,
+        routesByKey: {},
+        sourceObjectsById: {},
+        unresolvedModule: true
+      };
+    }
+    log?.(
+      `[changelog] resolved module for commit ${commit.sha.slice(0, 12)}: ${resolvedModuleRel}`
+    );
+    const modulePath = import_node_path4.default.resolve(worktreeDir, resolvedModuleRel);
     let snapshotRuntimePath = modulePath;
     let resolvedTsconfigPath;
     if (isTypeScriptModule(modulePath)) {
@@ -2065,7 +2155,7 @@ async function createSnapshot(repoRoot, moduleRel, exportName, commit, tempRoot,
       );
       snapshotRuntimePath = await compileSnapshotEntry({
         worktreeDir,
-        moduleRel,
+        moduleRel: resolvedModuleRel,
         modulePath,
         tsconfigPath: resolvedTsconfigPath,
         commitSha: commit.sha,
@@ -2322,12 +2412,18 @@ async function exportFinalizedLeavesChangelog(options) {
   log("[changelog] resolving commit window");
   const window = await resolveCommitWindow(repoRoot, options.from, options.to);
   log(`[changelog] window: ${window.from.slice(0, 12)}..${window.to.slice(0, 12)}`);
+  const moduleCandidates = await buildModulePathCandidates(
+    repoRoot,
+    window.to,
+    modulePathRelative
+  );
+  log(`[changelog] module candidates discovered: ${moduleCandidates.length}`);
   const allCommits = await resolveCommitPath(repoRoot, window.from, window.to);
   log(`[changelog] commits in ancestry path: ${allCommits.length}`);
   const selectedCommitShas = await filterCommits(
     repoRoot,
     allCommits,
-    modulePathRelative,
+    moduleCandidates,
     tsconfigRelative
   );
   log(`[changelog] commits after path filter: ${selectedCommitShas.length}`);
@@ -2344,6 +2440,7 @@ async function exportFinalizedLeavesChangelog(options) {
   log(`[changelog] temp workspace: ${tempRoot}`);
   try {
     const snapshots = [];
+    const unresolvedModuleCommits = [];
     for (let index = 0; index < commits.length; index += 1) {
       const commit = commits[index];
       log(
@@ -2352,7 +2449,7 @@ async function exportFinalizedLeavesChangelog(options) {
       snapshots.push(
         await createSnapshot(
           repoRoot,
-          modulePathRelative,
+          moduleCandidates,
           exportName,
           commit,
           tempRoot,
@@ -2361,6 +2458,9 @@ async function exportFinalizedLeavesChangelog(options) {
           log
         )
       );
+      if (snapshots[snapshots.length - 1]?.unresolvedModule) {
+        unresolvedModuleCommits.push(commit.sha);
+      }
     }
     const routeEvents = [];
     const sourceEvents = [];
@@ -2385,7 +2485,8 @@ async function exportFinalizedLeavesChangelog(options) {
         exportName,
         from: window.from,
         to: window.to,
-        selectedCommitCount: commits.length
+        selectedCommitCount: commits.length,
+        unresolvedModuleCommits: unresolvedModuleCommits.length > 0 ? unresolvedModuleCommits : void 0
       },
       commits,
       byRoute: routeRecordByKey(routeEvents),
@@ -2412,6 +2513,8 @@ var __private = {
   resolveCommitWindow,
   resolveCommitPath,
   filterCommits,
+  buildModulePathCandidates,
+  resolveModulePathForCommit,
   resolveSnapshotTsconfig,
   toEmittedModulePath,
   buildCompileCacheKey,