@cosmicdrift/kumiko-framework 0.220.0 → 0.221.0

package/src/upgrade-cli.ts

@@ -4,6 +4,7 @@ import {
   readdirSync,
   readFileSync,
   realpathSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
@@ -170,7 +171,23 @@ export function findFeaturesDirs(cwd: string): string[] {
 // node_modules after a plain npm/bun install (fw#2301).
 export function findCodemodScriptsRoot(repoRoot: string): string | null {
   const local = join(repoRoot, "packages/framework/src");
-  if (existsSync(join(local, CODEMOD_SUBDIR))) return local;
+  if (existsSync(join(local, CODEMOD_SUBDIR))) {
+    // If package.json exists, require it to be kumiko-framework so a generic
+    // monorepo `packages/framework` cannot shadow the installed package.
+    // Missing package.json (test fixtures / incomplete trees) keeps prior behavior.
+    const pkgPath = join(repoRoot, "packages/framework/package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { name?: string };
+        if (pkg.name === "@cosmicdrift/kumiko-framework") return local;
+        // wrong name → fall through
+      } catch {
+        // unreadable → fall through
+      }
+    } else {
+      return local;
+    }
+  }
 
   let dir = repoRoot;
   for (let i = 0; i < 10; i++) {
@@ -187,7 +204,10 @@ export function findCodemodScriptsRoot(repoRoot: string): string | null {
 // Resolves a changes.json `codemod` field to an absolute script path,
 // refusing anything that would escape scripts/codemod/ (path traversal,
 // absolute paths, symlinks pointing outward) or that isn't a real .ts file.
-export function resolveCodemodScript(
+// First arg is the consumer repo root (same as findCodemodScriptsRoot) —
+// not the scripts root — so out-of-tree callers keep compiling against the
+// public upgrade-cli subpath without silently resolving to null (fw#2341).
+function resolveCodemodScriptAt(
   codemodScriptsRoot: string,
   codemodField: string | undefined,
 ): string | null {
@@ -213,6 +233,15 @@ export function resolveCodemodScript(
   return resolved;
 }
 
+export function resolveCodemodScript(
+  repoRoot: string,
+  codemodField: string | undefined,
+): string | null {
+  const scriptsRoot = findCodemodScriptsRoot(repoRoot);
+  if (!scriptsRoot) return null;
+  return resolveCodemodScriptAt(scriptsRoot, codemodField);
+}
+
 type CodemodRunResult = { readonly ok: boolean; readonly output: string };
 
 // Array-form argv only — never a shell string. The script itself decides
@@ -254,6 +283,42 @@ function writeUpgradeMarker(targetDir: string, marker: UpgradeMarker): void {
   writeFileSync(join(dir, "upgrade-state.json"), `${JSON.stringify(marker, null, 2)}\n`, "utf-8");
 }
 
+/** Highest pending version strictly below the earliest open manual breaking
+ *  entry (no codemod). Falls back to highest non-breaking pending when every
+ *  pending version is at/after that manual — never advances onto the manual. */
+/** Highest pending version strictly below the earliest open manual breaking
+ *  entry (no codemod). Falls back to highest non-breaking pending when every
+ *  pending version is at/after that manual. If only manuals remain, returns
+ *  `fallbackInstalled` so the marker stamp moves without claiming manuals done. */
+function markerVersionForPending(
+  pending: readonly ChangelogEntry[],
+  manualEntries: readonly ChangelogEntry[],
+  fallbackInstalled: string,
+): string {
+  const earliestManual = [...manualEntries].sort((a, b) =>
+    compareVersions(a.version, b.version),
+  )[0];
+  const eligible = pending.filter(
+    (e) => earliestManual === undefined || compareVersions(e.version, earliestManual.version) < 0,
+  );
+  const headEligible = eligible[0];
+  if (headEligible !== undefined) {
+    return eligible.reduce(
+      (max, e) => (compareVersions(e.version, max) > 0 ? e.version : max),
+      headEligible.version,
+    );
+  }
+  const nonBreaking = pending.filter((e) => e.type !== "breaking");
+  const headNonBreaking = nonBreaking[0];
+  if (headNonBreaking !== undefined) {
+    return nonBreaking.reduce(
+      (max, e) => (compareVersions(e.version, max) > 0 ? e.version : max),
+      headNonBreaking.version,
+    );
+  }
+  return fallbackInstalled;
+}
+
 // Runs every pending breaking entry's codemod, oldest version first (so a
 // later codemod can assume an earlier one already ran). Stops on the first
 // failure — no partial marker. Writes the marker whenever dryRun is false —
@@ -265,13 +330,16 @@ async function applyCodemods(
   repoRoot: string,
   targetDir: string,
   dryRun: boolean,
-  currentVersion: string,
+  // Installed version for the zero-pending bootstrap marker — never a
+  // `--from` filter override (that would permanently skip real pending
+  // codemods once the CI guard compares against the fake marker).
+  markerVersion: string,
 ): Promise<number> {
   if (pending.length === 0) {
     out.log("  ✓ Nothing new since your version.");
     if (!dryRun) {
       writeUpgradeMarker(targetDir, {
-        version: currentVersion,
+        version: markerVersion,
         appliedAt: Temporal.Now.instant().toString(),
         codemods: [],
       });
@@ -296,15 +364,28 @@ async function applyCodemods(
         ? "  No automatable codemods among the pending breaking changes."
         : "  ✓ No breaking changes pending.",
     );
+    if (!dryRun) {
+      const markerVer = markerVersionForPending(pending, manualEntries, markerVersion);
+      writeUpgradeMarker(targetDir, {
+        version: markerVer,
+        appliedAt: Temporal.Now.instant().toString(),
+        codemods: [],
+      });
+      out.log(`  ✓ Applied 0 codemod(s). Wrote ${join(targetDir, ".kumiko/upgrade-state.json")}`);
+    }
     return 0;
   }
 
   const codemodScriptsRoot = findCodemodScriptsRoot(repoRoot);
+  if (codemodScriptsRoot === null) {
+    out.err(
+      `  ✗ could not locate @cosmicdrift/kumiko-framework/src/scripts/codemod — is the framework installed? searched from ${repoRoot} upward`,
+    );
+    return 1;
+  }
   const ran: UpgradeMarkerCodemod[] = [];
   for (const e of codemodEntries) {
-    const scriptPath = codemodScriptsRoot
-      ? resolveCodemodScript(codemodScriptsRoot, e.codemod)
-      : null;
+    const scriptPath = resolveCodemodScript(repoRoot, e.codemod);
     if (!scriptPath) {
       out.err(`  ✗ ${e.version} · ${e.title} — invalid codemod path "${e.codemod}"`);
       return 1;
@@ -325,10 +406,7 @@ async function applyCodemods(
     return 0;
   }
 
-  const latestVersion = pending.reduce(
-    (max, e) => (compareVersions(e.version, max) > 0 ? e.version : max),
-    pending[0]!.version,
-  );
+  const latestVersion = markerVersionForPending(pending, manualEntries, markerVersion);
   writeUpgradeMarker(targetDir, {
     version: latestVersion,
     appliedAt: Temporal.Now.instant().toString(),
@@ -396,9 +474,19 @@ export async function runUpgradeCli(
   if (getFlag(args, "apply")) {
     const dirFlag = getStringFlag(args, "dir");
     const targetDir = dirFlag ? resolve(dirFlag) : cwd;
+    if (!existsSync(targetDir) || !statSync(targetDir).isDirectory()) {
+      out.err("");
+      out.err(`  --dir path is not a directory: ${targetDir}`);
+      out.err("");
+      return 1;
+    }
+    // Marker must reflect what is actually installed under the target (or
+    // cwd), not a `--from` filter override — otherwise CI stays green forever.
+    const markerVersion =
+      (dirFlag ? readCurrentVersion(targetDir) : null) ?? installedVersion ?? currentVersion;
     const dryRun = getFlag(args, "dry-run");
     out.log("");
-    const code = await applyCodemods(out, pending, repoRoot, targetDir, dryRun, currentVersion);
+    const code = await applyCodemods(out, pending, repoRoot, targetDir, dryRun, markerVersion);
     out.log("");
     return code;
   }