@astryxdesign/cli 0.6.3 → 0.6.4-canary.0e1fbdb

package/assets/codemods/run-codemod.mjs

@@ -31,7 +31,12 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as p from './term-log.mjs';
 import {findConfigPath} from '../../foundation/config/project.mjs';
-import {fixDirectiveCorruption, validateOutput, IGNORED_DIRS} from './runner.mjs';
+import {
+  fixDirectiveCorruption,
+  validateOutput,
+  isIgnoredDirectory,
+} from './runner.mjs';
+import {createFileProtectionResolver} from '../../foundation/fs/file-protection.mjs';
 
 export const DEFAULT_CODE_EXTENSIONS = [
   '.tsx',
@@ -43,6 +48,41 @@ export const DEFAULT_CODE_EXTENSIONS = [
 ];
 const PARSEABLE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs'];
 
+/**
+ * @typedef {{file: string, codemod: string, reason: string, declaration: string, generated: boolean, command?: string}} ProtectedFile
+ */
+
+/**
+ * Convert every effective protection declaration into the stable codemod result
+ * shape. A file can carry more than one additive declaration.
+ * @param {string} filePath
+ * @param {string} name
+ * @param {{root: string, classify: (file: string) => import('../../foundation/fs/file-protection.mjs').FileProtection[]}} protection
+ * @returns {ProtectedFile[]}
+ */
+function protectedResult(filePath, name, protection) {
+  return protection.classify(filePath).map(item => ({
+    file: item.file,
+    codemod: name,
+    reason: item.reason,
+    declaration: item.declaration,
+    generated: item.reason === 'generated',
+    ...(item.command ? {command: item.command} : {}),
+  }));
+}
+
+/**
+ * Print one blocked candidate without implying that the protected bytes changed.
+ * @param {import('../../authoring/codemod/type').CliLog} log
+ * @param {ProtectedFile[]} protections
+ */
+function logProtected(log, protections) {
+  const [first] = protections;
+  log.warn(
+    `    ! ${first.file} — protected by ${protections.map(item => item.declaration).join('; ')}`,
+  );
+}
+
 /**
  * Recursively find candidate source files in a directory.
  * @param {string} dir
@@ -51,8 +91,17 @@ const PARSEABLE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs'];
 export function findSourceFiles(dir) {
   /** @type {string[]} */
   const results = [];
-  /** @param {string} currentDir */
-  function walk(currentDir) {
+  /** @param {string} currentDir @param {Set<string>} [ancestors] */
+  function walk(currentDir, ancestors = new Set()) {
+    let realDirectory;
+    try {
+      realDirectory = fs.realpathSync(currentDir);
+    } catch {
+      return;
+    }
+    if (ancestors.has(realDirectory)) return;
+    const nextAncestors = new Set(ancestors);
+    nextAncestors.add(realDirectory);
     let entries;
     try {
       entries = fs.readdirSync(currentDir, {withFileTypes: true});
@@ -61,12 +110,21 @@ export function findSourceFiles(dir) {
     }
     for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
-      // Never follow symlinks — writing through one would rewrite its target
-      // outside the scan tree (e.g. into node_modules or anywhere on disk).
-      if (entry.isSymbolicLink()) continue;
+      // Symlinked files and descendants remain read-only candidates so a
+      // required change can be reported. Real-path ancestors prevent cycles.
+      if (entry.isSymbolicLink()) {
+        try {
+          const target = fs.statSync(fullPath);
+          if (target.isFile()) results.push(fullPath);
+          else if (target.isDirectory()) walk(fullPath, nextAncestors);
+        } catch {
+          // Broken links have no source bytes to evaluate.
+        }
+        continue;
+      }
       if (entry.isDirectory()) {
-        if (IGNORED_DIRS.has(entry.name)) continue;
-        walk(fullPath);
+        if (isIgnoredDirectory(dir, fullPath, entry.name)) continue;
+        walk(fullPath, nextAncestors);
       } else {
         results.push(fullPath);
       }
@@ -91,37 +149,45 @@ export function makeLog(silent) {
  * Apply a config codemod to the consumer's astryx.config.* file.
  *
  * @param {import('../../authoring/codemod/type').CodemodEntry} entry normalized codemod entry {id, codemod, package}
- * @param {{apply: boolean, log: import('../../authoring/codemod/type').CliLog, jscodeshift: import('../../authoring/codemod/type').JscodeshiftFactory}} ctx
+ * @param {{apply: boolean, log: import('../../authoring/codemod/type').CliLog, jscodeshift: import('../../authoring/codemod/type').JscodeshiftFactory, root?: string, protection: {root: string, classify: (file: string) => import('../../foundation/fs/file-protection.mjs').FileProtection[]}, contents?: Map<string, string>}} ctx
  * @returns {import('../../authoring/codemod/type').CodemodRunResult}
  */
-export function runConfigCodemod(entry, {apply, log, jscodeshift}) {
+export function runConfigCodemod(
+  entry,
+  {apply, log, jscodeshift, root = process.cwd(), protection, contents},
+) {
   const {codemod, id, package: pkg} = entry;
   const name = `${pkg}:${id}`;
-  // findConfigPath throws when multiple astryx.config.* files coexist. Config
-  // codemods run FIRST (before the strict project loader), so an uncaught throw
-  // here aborts the entire `astryx upgrade` with an un-coded error — breaking
-  // the per-codemod isolation every other failure path honors. Degrade it to a
-  // structured error so the run continues and reports it.
+  const resolver = protection ?? createFileProtectionResolver(root);
   let configPath;
   try {
-    configPath = findConfigPath(process.cwd());
+    configPath = findConfigPath(root);
   } catch (err) {
     const message = /** @type {any} */ (err).message;
     log.error(`    ✗ astryx.config.* — ${message}`);
     return {
       filesChanged: 0,
+      changedFiles: [],
       writtenFiles: [],
+      protectedFiles: [],
       errors: [{file: 'astryx.config.*', codemod: name, error: message}],
     };
   }
   if (!configPath) {
     log.info(`  ${codemod.title} — no astryx.config.* found; skipping.`);
-    return {filesChanged: 0, writtenFiles: [], errors: []};
+    return {
+      filesChanged: 0,
+      changedFiles: [],
+      writtenFiles: [],
+      protectedFiles: [],
+      errors: [],
+    };
   }
 
-  const relativePath = path.relative(process.cwd(), configPath);
+  const relativePath = path.relative(root, configPath);
   try {
-    const source = fs.readFileSync(configPath, 'utf-8');
+    const source =
+      contents?.get(configPath) ?? fs.readFileSync(configPath, 'utf-8');
     const ext = path.extname(configPath);
     const parser = ext === '.tsx' || ext === '.ts' ? 'tsx' : 'babel';
     const j = jscodeshift.withParser(parser);
@@ -129,7 +195,13 @@ export function runConfigCodemod(entry, {apply, log, jscodeshift}) {
     let result = codemod.transform({source, path: configPath}, api);
 
     if (result == null || result === source) {
-      return {filesChanged: 0, writtenFiles: [], errors: []};
+      return {
+        filesChanged: 0,
+        changedFiles: [],
+        writtenFiles: [],
+        protectedFiles: [],
+        errors: [],
+      };
     }
 
     result = fixDirectiveCorruption(result);
@@ -140,11 +212,26 @@ export function runConfigCodemod(entry, {apply, log, jscodeshift}) {
       log.error(`    ✗ ${relativePath} — ${validation.reason}`);
       return {
         filesChanged: 0,
+        changedFiles: [],
         writtenFiles: [],
+        protectedFiles: [],
         errors: [{file: relativePath, codemod: name, error: validation.reason}],
       };
     }
 
+    const protectedFiles = protectedResult(configPath, name, resolver);
+    if (protectedFiles.length > 0) {
+      logProtected(log, protectedFiles);
+      return {
+        filesChanged: 0,
+        changedFiles: [],
+        writtenFiles: [],
+        protectedFiles,
+        errors: [],
+      };
+    }
+
+    contents?.set(configPath, result);
     if (apply) {
       fs.writeFileSync(configPath, result, 'utf-8');
       log.success(`    ✓ ${relativePath}`);
@@ -153,7 +240,9 @@ export function runConfigCodemod(entry, {apply, log, jscodeshift}) {
     }
     return {
       filesChanged: 1,
+      changedFiles: [configPath],
       writtenFiles: apply ? [configPath] : [],
+      protectedFiles: [],
       errors: [],
     };
   } catch (err) {
@@ -161,7 +250,9 @@ export function runConfigCodemod(entry, {apply, log, jscodeshift}) {
     log.error(`    ✗ ${relativePath} — ${message}`);
     return {
       filesChanged: 0,
+      changedFiles: [],
       writtenFiles: [],
+      protectedFiles: [],
       errors: [{file: relativePath, codemod: name, error: message}],
     };
   }
@@ -172,27 +263,41 @@ export function runConfigCodemod(entry, {apply, log, jscodeshift}) {
  *
  * @param {import('../../authoring/codemod/type').CodemodEntry} entry normalized codemod entry {id, codemod, package}
  * @param {string[]} files
- * @param {{apply: boolean, log: import('../../authoring/codemod/type').CliLog, jscodeshift: import('../../authoring/codemod/type').JscodeshiftFactory}} ctx
+ * @param {{apply: boolean, log: import('../../authoring/codemod/type').CliLog, jscodeshift: import('../../authoring/codemod/type').JscodeshiftFactory, root?: string, protection: {root: string, classify: (file: string) => import('../../foundation/fs/file-protection.mjs').FileProtection[]}, contents?: Map<string, string>}} ctx
  * @returns {import('../../authoring/codemod/type').CodemodRunResult}
  */
-export function runCodeCodemod(entry, files, {apply, log, jscodeshift}) {
+export function runCodeCodemod(
+  entry,
+  files,
+  {apply, log, jscodeshift, root = process.cwd(), protection, contents},
+) {
   const {codemod, id, package: pkg} = entry;
   const name = `${pkg}:${id}`;
+  const resolver = protection ?? createFileProtectionResolver(root);
   const extensions = new Set(codemod.fileExtensions ?? DEFAULT_CODE_EXTENSIONS);
 
   let filesChanged = 0;
   /** @type {string[]} */
+  const changedFiles = [];
+  /** @type {string[]} */
   const writtenFiles = [];
+  /** @type {ProtectedFile[]} */
+  const protectedFiles = [];
   /** @type {Array<{file: string, codemod: string, error: string}>} */
   const errors = [];
+  /** @type {Array<{filePath: string, relativePath: string, result: string}>} */
+  const candidates = [];
 
+  // Transform and validate every candidate before any write. This lets a
+  // protection source changed by this entry govern every other staged output.
   for (const filePath of files) {
     const ext = path.extname(filePath);
     if (!extensions.has(ext)) continue;
 
-    const relativePath = path.relative(process.cwd(), filePath);
+    const relativePath = path.relative(root, filePath);
     try {
-      const source = fs.readFileSync(filePath, 'utf-8');
+      const source =
+        contents?.get(filePath) ?? fs.readFileSync(filePath, 'utf-8');
       const parser = ext === '.tsx' || ext === '.ts' ? 'tsx' : 'babel';
       const j = jscodeshift.withParser(parser);
       const api = {jscodeshift: j, stats: () => {}, report: () => {}};
@@ -213,15 +318,7 @@ export function runCodeCodemod(entry, files, {apply, log, jscodeshift}) {
         });
         continue;
       }
-
-      filesChanged++;
-      if (apply) {
-        fs.writeFileSync(filePath, result, 'utf-8');
-        writtenFiles.push(filePath);
-        log.success(`    ✓ ${relativePath}`);
-      } else {
-        log.warn(`    ~ ${relativePath} (would change)`);
-      }
+      candidates.push({filePath, relativePath, result});
     } catch (err) {
       const message = /** @type {any} */ (err).message;
       log.error(`    ✗ ${relativePath} — ${message}`);
@@ -229,5 +326,51 @@ export function runCodeCodemod(entry, files, {apply, log, jscodeshift}) {
     }
   }
 
-  return {filesChanged, writtenFiles, errors};
+  /** @type {Map<string, ProtectedFile[]>} */
+  const currentProtections = new Map();
+  /** @type {Map<string, string|null>} */
+  const stagedContents = new Map(contents ?? []);
+  for (const candidate of candidates) {
+    const blocked = protectedResult(candidate.filePath, name, resolver);
+    currentProtections.set(candidate.filePath, blocked);
+    if (blocked.length === 0) {
+      stagedContents.set(candidate.filePath, candidate.result);
+    }
+  }
+  const stagedResolver = createFileProtectionResolver(root, {
+    overrides: stagedContents,
+  });
+
+  for (const candidate of candidates) {
+    const blocked = [
+      ...(currentProtections.get(candidate.filePath) ?? []),
+      ...protectedResult(candidate.filePath, name, stagedResolver),
+    ].filter(
+      (item, index, all) =>
+        all.findIndex(
+          candidateItem =>
+            candidateItem.file === item.file &&
+            candidateItem.reason === item.reason &&
+            candidateItem.declaration === item.declaration,
+        ) === index,
+    );
+    if (blocked.length > 0) {
+      protectedFiles.push(...blocked);
+      logProtected(log, blocked);
+      continue;
+    }
+
+    filesChanged++;
+    changedFiles.push(candidate.filePath);
+    contents?.set(candidate.filePath, candidate.result);
+    if (apply) {
+      fs.writeFileSync(candidate.filePath, candidate.result, 'utf-8');
+      writtenFiles.push(candidate.filePath);
+      log.success(`    ✓ ${candidate.relativePath}`);
+    } else {
+      log.warn(`    ~ ${candidate.relativePath} (would change)`);
+    }
+  }
+
+  return {filesChanged, changedFiles, writtenFiles, protectedFiles, errors};
 }