@git.zone/cli 6.6.2 → 6.7.1

package/ts/helpers.workflow.ts

@@ -39,6 +39,7 @@ export interface IReleaseGitTargetConfig {
 
 export interface IReleaseNpmTargetConfig {
   enabled?: boolean;
+  packageSource?: "root" | "tspublish";
   registries?: string[];
   accessLevel?: "public" | "private";
   alreadyPublished?: "success" | "error";
@@ -107,6 +108,7 @@ export interface IResolvedReleaseWorkflow {
   pushTags: boolean;
   npmEnabled: boolean;
   npmRegistries: string[];
+  npmPackageSource: "root" | "tspublish";
   npmAccessLevel: "public" | "private";
   npmAlreadyPublished: "success" | "error";
   dockerEnabled: boolean;
@@ -123,6 +125,7 @@ export interface IResolvedReleaseWorkflow {
 
 export interface IResolvedReleaseResumeConfiguration {
   gitRemote: string;
+  npmPackageSource: "root" | "tspublish";
   npmRegistries: string[];
   npmAccessLevel: "public" | "private";
   npmAlreadyPublished: "success" | "error";
@@ -581,6 +584,14 @@ export const resolveCommitWorkflow = async (
   };
 };
 
+const resolveNpmPackageSource = (valueArg: unknown): "root" | "tspublish" => {
+  if (valueArg === undefined || valueArg === "root") return "root";
+  if (valueArg === "tspublish") return valueArg;
+  throw new Error(
+    "release.targets.npm.packageSource must be root or tspublish",
+  );
+};
+
 export const resolveReleaseWorkflow = async (
   argvArg: any,
 ): Promise<IResolvedReleaseWorkflow> => {
@@ -690,6 +701,9 @@ export const resolveReleaseWorkflow = async (
     pushTags,
     npmEnabled,
     npmRegistries,
+    npmPackageSource: targets.includes("npm")
+      ? resolveNpmPackageSource(npmConfig.packageSource)
+      : "root",
     npmAccessLevel: npmConfig.accessLevel || "public",
     npmAlreadyPublished: npmConfig.alreadyPublished || "success",
     dockerEnabled,
@@ -759,6 +773,9 @@ export const resolveReleaseResumeConfiguration = async (optionsArg: {
   return {
     gitRemote,
     npmRegistries,
+    npmPackageSource: optionsArg.npm
+      ? resolveNpmPackageSource(npmConfig.packageSource)
+      : "root",
     npmAccessLevel,
     npmAlreadyPublished,
   };

package/ts/mod_config/index.ts

@@ -2001,6 +2001,9 @@ async function validateNpmTarget(
       fix: "Use success or error.",
     });
   }
+  if (npmTarget.packageSource !== undefined && !["root", "tspublish"].includes(npmTarget.packageSource)) {
+    findings.push({ level: "error", message: `Invalid npm package source: ${npmTarget.packageSource}`, fix: "Use root or tspublish." });
+  }
 
   const smartNetwork = new plugins.smartnetwork.SmartNetwork();
   await Promise.all(

package/ts/mod_deprecate/helpers.deprecation.ts

@@ -0,0 +1,151 @@
+import * as plugins from "./mod.plugins.js";
+import { normalizeNpmRegistryUrl } from "../mod_release/helpers.npmartifact.js";
+
+export interface IDeprecationPlan {
+  packageName: string;
+  replacement: string;
+  message: string;
+  registries: string[];
+}
+
+export const createDeprecationPlan = (
+  options: Omit<IDeprecationPlan, "message"> & { message?: string },
+): IDeprecationPlan => {
+  const namePattern = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+  if (
+    typeof options.packageName !== "string" ||
+    typeof options.replacement !== "string" ||
+    !namePattern.test(options.packageName) ||
+    !namePattern.test(options.replacement) ||
+    options.packageName === options.replacement
+  )
+    throw new Error(
+      "Deprecation requires distinct valid package and replacement names.",
+    );
+  if (!Array.isArray(options.registries))
+    throw new Error("Invalid deprecation registries.");
+  const registries = options.registries.map(normalizeNpmRegistryUrl);
+  if (!registries.length || new Set(registries).size !== registries.length)
+    throw new Error("Deprecation requires unique explicit registries.");
+  const message =
+    options.message ??
+    `Use ${options.replacement}. ${options.packageName} is deprecated.`;
+  if (
+    typeof message !== "string" ||
+    !message.trim() ||
+    message.length > 2000 ||
+    /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(message)
+  ) {
+    throw new Error("Invalid deprecation message.");
+  }
+  return {
+    packageName: options.packageName,
+    replacement: options.replacement,
+    registries,
+    message,
+  };
+};
+
+interface IPackageMetadata {
+  name: string;
+  versions: Record<string, { deprecated?: string }>;
+  "dist-tags"?: Record<string, string>;
+}
+
+const readMetadata = async (
+  registry: string,
+  packageName: string,
+  fetchImplementation: typeof fetch,
+): Promise<IPackageMetadata> => {
+  const response = await fetchImplementation(
+    `${registry}/${encodeURIComponent(packageName)}`,
+    {
+      method: "GET",
+      redirect: "error",
+      signal: AbortSignal.timeout(30_000),
+      headers: { accept: "application/json" },
+    },
+  );
+  if (!response.ok)
+    throw new Error(
+      `Cannot verify ${packageName} on ${registry} (HTTP ${response.status}).`,
+    );
+  const metadata = await response.json();
+  if (
+    !metadata ||
+    metadata.name !== packageName ||
+    !metadata.versions ||
+    typeof metadata.versions !== "object" ||
+    Array.isArray(metadata.versions) ||
+    !Object.keys(metadata.versions).length ||
+    Object.values(metadata.versions).some(
+      (version) =>
+        !version || typeof version !== "object" || Array.isArray(version),
+    )
+  ) {
+    throw new Error(
+      `Invalid registry metadata for ${packageName} on ${registry}.`,
+    );
+  }
+  return metadata;
+};
+
+/** Verify replacements everywhere before changing metadata for any old package. */
+export const executeDeprecation = async (
+  planArg: IDeprecationPlan,
+  shell: plugins.smartshell.Smartshell,
+  cwd: string,
+  fetchImplementation: typeof fetch = fetch,
+): Promise<void> => {
+  const plan = createDeprecationPlan(planArg);
+  for (const registry of plan.registries) {
+    const replacement = await readMetadata(
+      registry,
+      plan.replacement,
+      fetchImplementation,
+    );
+    const latestTag = replacement["dist-tags"]?.latest;
+    const latest =
+      typeof latestTag === "string"
+        ? replacement.versions[latestTag]
+        : undefined;
+    if (!latest || latest.deprecated)
+      throw new Error(
+        `Replacement ${plan.replacement} has no active latest version on ${registry}.`,
+      );
+    await readMetadata(registry, plan.packageName, fetchImplementation);
+  }
+  for (const registry of plan.registries) {
+    const result = await shell.execSpawn(
+      "pnpm",
+      [
+        "deprecate",
+        `${plan.packageName}@*`,
+        plan.message,
+        "--registry",
+        registry,
+      ],
+      {
+        cwd,
+        timeout: 120_000,
+        timeoutKillGraceMs: 5_000,
+      },
+    );
+    if (result.exitCode !== 0)
+      throw new Error(`Deprecation failed on ${registry}.`);
+    const metadata = await readMetadata(
+      registry,
+      plan.packageName,
+      fetchImplementation,
+    );
+    const versions = Object.values(metadata.versions);
+    if (
+      !versions.length ||
+      versions.some((version) => version.deprecated !== plan.message)
+    ) {
+      throw new Error(
+        `Deprecation is not yet verified for every version on ${registry}; rerunning the same deprecation is safe.`,
+      );
+    }
+  }
+};

package/ts/mod_deprecate/index.ts

@@ -1,52 +1,103 @@
-import * as plugins from './mod.plugins.js';
+import * as plugins from "./mod.plugins.js";
 
-import { logger } from '../gitzone.logging.js';
+import { logger } from "../gitzone.logging.js";
+import { getCliMode, printJson } from "../helpers.climode.js";
+import {
+  createDeprecationPlan,
+  executeDeprecation,
+} from "./helpers.deprecation.js";
 
-export const run = async () => {
-  const smartInteract = new plugins.smartinteract.SmartInteract([
-    {
-      name: `registryUrls`,
-      message: `What are the comma separated registry URLs?`,
-      type: `input`,
-      default: `https://registry.npmjs.org`,
-      validate: (stringInput) => {
-        return stringInput !== '' && !process.env.CI;
+export const run = async (argvArg: any = {}) => {
+  const mode = await getCliMode(argvArg);
+  if (mode.help) {
+    console.log(
+      "gitzone deprecate --package <old> --replacement <new> --registries <url,url> [--message <text>] [--plan] [-y]",
+    );
+    console.log(
+      "Deprecates all versions after verifying the replacement on every registry.",
+    );
+    return;
+  }
+  let registryInput = argvArg.registries;
+  let oldPackageName = argvArg.package;
+  let newPackageName = argvArg.replacement;
+  if (!registryInput || !oldPackageName || !newPackageName) {
+    if (!mode.interactive || argvArg.plan || mode.json)
+      throw new Error("Specify --package, --replacement, and --registries.");
+    const smartInteract = new plugins.smartinteract.SmartInteract([
+      {
+        name: `registryUrls`,
+        message: `What are the comma separated registry URLs?`,
+        type: `input`,
+        default: `https://registry.npmjs.org`,
+        validate: (stringInput) => {
+          return stringInput !== "" && !process.env.CI;
+        },
       },
-    },
-    {
-      name: `oldPackageName`,
-      message: `Whats the name of the OLD package?`,
-      type: `input`,
-      default: ``,
-      validate: (stringInput) => {
-        return stringInput !== '' && !process.env.CI;
+      {
+        name: `oldPackageName`,
+        message: `Whats the name of the OLD package?`,
+        type: `input`,
+        default: ``,
+        validate: (stringInput) => {
+          return stringInput !== "" && !process.env.CI;
+        },
       },
-    },
-    {
-      name: `newPackageName`,
-      message: `Whats the name of the NEW package?`,
-      type: `input`,
-      default: ``,
-      validate: (stringInput) => {
-        return stringInput !== '' && !process.env.CI;
+      {
+        name: `newPackageName`,
+        message: `Whats the name of the NEW package?`,
+        type: `input`,
+        default: ``,
+        validate: (stringInput) => {
+          return stringInput !== "" && !process.env.CI;
+        },
       },
-    },
-  ]);
-  const answerBucket = await smartInteract.runQueue();
-  const registryUrls = answerBucket.getAnswerFor(`registryUrls`).split(',');
-  const oldPackageName = answerBucket.getAnswerFor(`oldPackageName`);
-  const newPackageName = answerBucket.getAnswerFor(`newPackageName`);
+    ]);
+    const answerBucket = await smartInteract.runQueue();
+    registryInput = answerBucket.getAnswerFor("registryUrls");
+    oldPackageName = answerBucket.getAnswerFor("oldPackageName");
+    newPackageName = answerBucket.getAnswerFor("newPackageName");
+  }
+  if (
+    typeof registryInput !== "string" ||
+    typeof oldPackageName !== "string" ||
+    typeof newPackageName !== "string"
+  ) {
+    throw new Error("Deprecation arguments must be strings.");
+  }
+  const plan = createDeprecationPlan({
+    packageName: oldPackageName,
+    replacement: newPackageName,
+    registries: registryInput.split(",").map((value) => value.trim()),
+    message: argvArg.message,
+  });
+  if (mode.json) {
+    printJson({ ok: true, plan });
+    return;
+  }
+  console.log(JSON.stringify(plan, null, 2));
+  if (argvArg.plan) return;
+  if (!mode.yes) {
+    if (!mode.interactive)
+      throw new Error("Deprecation requires -y or interactive confirmation.");
+    if (
+      !(await plugins.smartinteract.SmartInteract.getCliConfirmation(
+        `Deprecate every version of ${oldPackageName}?`,
+        false,
+      ))
+    )
+      return;
+  }
   logger.log(
-    'info',
+    "info",
     `Deprecating package ${oldPackageName} in favour of ${newPackageName}`,
   );
   const smartshellInstance = new plugins.smartshell.Smartshell({
-    executor: 'bash',
+    executor: "bash",
   });
-  for (const registryUrl of registryUrls) {
-    await smartshellInstance.exec(
-      `npm deprecate ${oldPackageName}@* ` +
-        `"${oldPackageName} has been deprecated in favour of ${newPackageName} - please upgrade asap!!!" --registry ${registryUrl}`,
-    );
-  }
+  await executeDeprecation(plan, smartshellInstance, process.cwd());
+  logger.log(
+    "ok",
+    `Verified deprecation on ${plan.registries.length} registries.`,
+  );
 };

package/ts/mod_format/classes.baseformatter.ts

@@ -124,6 +124,60 @@ export abstract class BaseFormatter {
     await plugins.smartfs.file(filepath).delete();
   }
 
+  /**
+   * Rename a file, preserving git history where the repository tracks it.
+   * Uses `git mv` first and only falls back to a plain filesystem rename when
+   * git refuses (untracked file, no repository, ...).
+   */
+  protected async renameFile(fromPath: string, toPath: string): Promise<void> {
+    if (!fromPath || !toPath || fromPath === toPath) {
+      throw new Error(`Invalid rename from "${fromPath}" to "${toPath}"`);
+    }
+
+    const sourceExists = await plugins.smartfs.file(fromPath).exists();
+    if (!sourceExists) {
+      throw new Error(`Cannot rename ${fromPath}: file does not exist`);
+    }
+
+    const destinationExists = await plugins.smartfs.file(toPath).exists();
+    if (destinationExists) {
+      throw new Error(
+        `Cannot rename ${fromPath} to ${toPath}: destination already exists`,
+      );
+    }
+
+    const destinationDir = plugins.path.dirname(toPath);
+    if (destinationDir && destinationDir !== '.') {
+      await plugins.smartfs.directory(destinationDir).recursive().create();
+    }
+
+    let gitRenamed = false;
+    try {
+      const smartshellInstance = new plugins.smartshell.Smartshell({
+        executor: 'bash',
+        sourceFilePaths: [],
+      });
+      const result = await smartshellInstance.execSpawn(
+        'git',
+        ['mv', fromPath, toPath],
+        { silent: true, timeout: 30_000, timeoutKillGraceMs: 5_000 },
+      );
+      gitRenamed = result.exitCode === 0;
+    } catch {
+      gitRenamed = false;
+    }
+
+    if (!gitRenamed) {
+      // A killed or timed out `git mv` may still have moved the file.
+      const movedAnyway =
+        !(await plugins.smartfs.file(fromPath).exists()) &&
+        (await plugins.smartfs.file(toPath).exists());
+      if (!movedAnyway) {
+        await plugins.fs.rename(fromPath, toPath);
+      }
+    }
+  }
+
   /**
    * Check for diffs without applying changes
    */
@@ -172,6 +226,19 @@ export abstract class BaseFormatter {
         } catch {
           // File doesn't exist, nothing to delete
         }
+      } else if (change.type === 'rename') {
+        if (!change.fromPath) {
+          continue;
+        }
+        const sourceExists = await plugins.smartfs.file(change.fromPath).exists();
+        if (!sourceExists) {
+          continue;
+        }
+        diffs.push({
+          path: change.path,
+          type: 'rename',
+          fromPath: change.fromPath,
+        });
       }
     }
 
@@ -183,6 +250,10 @@ export abstract class BaseFormatter {
 
   displayDiff(diff: ICheckResult['diffs'][0]): void {
     console.log(`\n--- ${diff.path}`);
+    if (diff.type === 'rename') {
+      console.log(`  (file will be renamed from ${diff.fromPath})`);
+      return;
+    }
     if (diff.before !== undefined && diff.after !== undefined) {
       console.log(plugins.smartdiff.formatUnifiedDiffForConsole(diff.before, diff.after, {
         originalFileName: diff.path,

package/ts/mod_format/classes.formatplanner.ts

@@ -5,6 +5,7 @@ import type {
   IFormatPlan,
   IPlannedChange,
   IFormatWarning,
+  TPlannedChangeType,
 } from './interfaces.format.js';
 import { getModuleIcon } from './interfaces.format.js';
 import { logger } from '../gitzone.logging.js';
@@ -21,6 +22,7 @@ export class FormatPlanner {
         filesAdded: 0,
         filesModified: 0,
         filesRemoved: 0,
+        filesRenamed: 0,
       },
       changes: [],
       warnings: [],
@@ -44,6 +46,9 @@ export class FormatPlanner {
             case 'delete':
               plan.summary.filesRemoved++;
               break;
+            case 'rename':
+              plan.summary.filesRenamed++;
+              break;
           }
         }
 
@@ -64,7 +69,8 @@ export class FormatPlanner {
     plan.summary.totalFiles =
       plan.summary.filesAdded +
       plan.summary.filesModified +
-      plan.summary.filesRemoved;
+      plan.summary.filesRemoved +
+      plan.summary.filesRenamed;
 
     return plan;
   }
@@ -100,6 +106,7 @@ export class FormatPlanner {
     console.log(`  • ${plan.summary.filesAdded} new files`);
     console.log(`  • ${plan.summary.filesModified} modified files`);
     console.log(`  • ${plan.summary.filesRemoved} deleted files`);
+    console.log(`  • ${plan.summary.filesRenamed} renamed files`);
     console.log('');
     console.log('Changes by module:');
 
@@ -117,7 +124,11 @@ export class FormatPlanner {
 
       for (const change of changes) {
         const icon = this.getChangeIcon(change.type);
-        console.log(`  ${icon} ${change.path} - ${change.description}`);
+        const pathLabel =
+          change.type === 'rename' && change.fromPath
+            ? `${change.fromPath} -> ${change.path}`
+            : change.path;
+        console.log(`  ${icon} ${pathLabel} - ${change.description}`);
 
         if (detailed && change.type === 'modify') {
           const diff = await this.diffReporter.generateDiffForChange(change);
@@ -139,7 +150,7 @@ export class FormatPlanner {
     console.log('\n' + '━'.repeat(50));
   }
 
-  private getChangeIcon(type: 'create' | 'modify' | 'delete'): string {
+  private getChangeIcon(type: TPlannedChangeType): string {
     switch (type) {
       case 'create':
         return '✅';
@@ -147,6 +158,8 @@ export class FormatPlanner {
         return '✏️';
       case 'delete':
         return '❌';
+      case 'rename':
+        return '🔁';
     }
   }
 

package/ts/mod_format/classes.formatstats.ts

@@ -1,6 +1,7 @@
 import * as plugins from './mod.plugins.js';
 import { logger } from '../gitzone.logging.js';
 import { getModuleIcon } from './interfaces.format.js';
+import type { TPlannedChangeType } from './interfaces.format.js';
 
 export interface IModuleStats {
   name: string;
@@ -11,6 +12,7 @@ export interface IModuleStats {
   filesCreated: number;
   filesModified: number;
   filesDeleted: number;
+  filesRenamed: number;
 }
 
 export interface IFormatStats {
@@ -23,6 +25,7 @@ export interface IFormatStats {
     totalCreated: number;
     totalModified: number;
     totalDeleted: number;
+    totalRenamed: number;
     totalErrors: number;
   };
 }
@@ -41,6 +44,7 @@ export class FormatStats {
         totalCreated: 0,
         totalModified: 0,
         totalDeleted: 0,
+        totalRenamed: 0,
         totalErrors: 0,
       },
     };
@@ -56,6 +60,7 @@ export class FormatStats {
       filesCreated: 0,
       filesModified: 0,
       filesDeleted: 0,
+      filesRenamed: 0,
     });
   }
 
@@ -72,7 +77,7 @@ export class FormatStats {
 
   recordFileOperation(
     moduleName: string,
-    operation: 'create' | 'modify' | 'delete',
+    operation: TPlannedChangeType,
     success: boolean = true,
   ): void {
     const moduleStats = this.stats.moduleStats.get(moduleName);
@@ -97,6 +102,10 @@ export class FormatStats {
           moduleStats.filesDeleted++;
           this.stats.overallStats.totalDeleted++;
           break;
+        case 'rename':
+          moduleStats.filesRenamed++;
+          this.stats.overallStats.totalRenamed++;
+          break;
       }
     } else {
       moduleStats.errors++;
@@ -122,6 +131,7 @@ export class FormatStats {
     console.log(`    • Created: ${this.stats.overallStats.totalCreated}`);
     console.log(`    • Modified: ${this.stats.overallStats.totalModified}`);
     console.log(`    • Deleted: ${this.stats.overallStats.totalDeleted}`);
+    console.log(`    • Renamed: ${this.stats.overallStats.totalRenamed}`);
     console.log(`  Errors: ${this.stats.overallStats.totalErrors}`);
 
     // Module stats
@@ -150,6 +160,9 @@ export class FormatStats {
       if (moduleStats.filesDeleted > 0) {
         console.log(`    • Deleted: ${moduleStats.filesDeleted}`);
       }
+      if (moduleStats.filesRenamed > 0) {
+        console.log(`    • Renamed: ${moduleStats.filesRenamed}`);
+      }
 
       if (moduleStats.errors > 0) {
         console.log(`  ❌ Errors: ${moduleStats.errors}`);