@git.zone/cli 2.14.3 → 2.16.0

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/cli',
-  version: '2.14.3',
+  version: '2.16.0',
   description: 'A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.'
 }

package/ts/gitzone.cli.ts

@@ -51,6 +51,14 @@ export let run = async () => {
     await modCommit.run(argvArg);
   });
 
+  /**
+   * create a release from pending changelog entries
+   */
+  gitzoneSmartcli.addCommand("release").subscribe(async (argvArg) => {
+    const modRelease = await import("./mod_release/index.js");
+    await modRelease.run(argvArg);
+  });
+
   /**
    * deprecate a package on npm
    */
@@ -129,6 +137,14 @@ export let run = async () => {
     modHelpers.run(argvArg);
   });
 
+  /**
+   * manage the global @git.zone toolchain
+   */
+  gitzoneSmartcli.addCommand("tools").subscribe(async (argvArg) => {
+    const modTools = await import("./mod_tools/index.js");
+    await modTools.run(argvArg);
+  });
+
   /**
    * manage release configuration
    */

package/ts/helpers.changelog.ts

@@ -0,0 +1,165 @@
+import * as plugins from "./plugins.js";
+
+export type TChangelogBucket =
+  | "Breaking Changes"
+  | "Features"
+  | "Fixes"
+  | "Documentation"
+  | "Maintenance";
+
+export interface IChangelogEntry {
+  type: string;
+  scope: string;
+  message: string;
+  details?: string[];
+}
+
+export interface IPendingChangelog {
+  block: string;
+  isEmpty: boolean;
+}
+
+const bucketForCommitType = (commitType: string): TChangelogBucket => {
+  switch (commitType) {
+    case "BREAKING CHANGE":
+      return "Breaking Changes";
+    case "feat":
+      return "Features";
+    case "fix":
+      return "Fixes";
+    case "docs":
+      return "Documentation";
+    default:
+      return "Maintenance";
+  }
+};
+
+const readChangelog = async (filePath: string): Promise<string> => {
+  if (!(await plugins.smartfs.file(filePath).exists())) {
+    return "# Changelog\n\n";
+  }
+  return (await plugins.smartfs.file(filePath).encoding("utf8").read()) as string;
+};
+
+const writeChangelog = async (filePath: string, content: string): Promise<void> => {
+  await plugins.smartfs.file(filePath).encoding("utf8").write(content.endsWith("\n") ? content : `${content}\n`);
+};
+
+const findPendingSection = (
+  content: string,
+  sectionName: string,
+): { start: number; bodyStart: number; end: number } | null => {
+  const headingRegex = new RegExp(`^##\\s+${sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`, "m");
+  const match = headingRegex.exec(content);
+  if (!match || match.index === undefined) {
+    return null;
+  }
+
+  const bodyStart = match.index + match[0].length;
+  const rest = content.slice(bodyStart);
+  const nextHeadingMatch = /^##\s+/m.exec(rest);
+  const end = nextHeadingMatch ? bodyStart + nextHeadingMatch.index : content.length;
+  return { start: match.index, bodyStart, end };
+};
+
+export const ensurePendingSection = async (
+  filePath: string,
+  sectionName = "Pending",
+): Promise<string> => {
+  let content = await readChangelog(filePath);
+  if (findPendingSection(content, sectionName)) {
+    return content;
+  }
+
+  const pendingSection = `## ${sectionName}\n\n`;
+  const titleMatch = /^#\s+.+$/m.exec(content);
+  if (titleMatch && titleMatch.index !== undefined) {
+    const insertAt = titleMatch.index + titleMatch[0].length;
+    content = `${content.slice(0, insertAt)}\n\n${pendingSection}${content.slice(insertAt).replace(/^\n+/, "")}`;
+  } else {
+    content = `# Changelog\n\n${pendingSection}${content}`;
+  }
+
+  await writeChangelog(filePath, content);
+  return content;
+};
+
+export const appendPendingChangelogEntry = async (
+  filePath: string,
+  sectionName: string,
+  entry: IChangelogEntry,
+): Promise<void> => {
+  let content = await ensurePendingSection(filePath, sectionName);
+  const pendingSection = findPendingSection(content, sectionName)!;
+  let pendingBody = content.slice(pendingSection.bodyStart, pendingSection.end);
+  const bucket = bucketForCommitType(entry.type);
+  const bucketHeading = `### ${bucket}`;
+
+  const entryLines = [`- ${entry.message}${entry.scope ? ` (${entry.scope})` : ""}`];
+  for (const detail of entry.details || []) {
+    entryLines.push(`  - ${detail}`);
+  }
+  const renderedEntry = entryLines.join("\n");
+
+  const bucketRegex = new RegExp(`^###\\s+${bucket.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`, "m");
+  const bucketMatch = bucketRegex.exec(pendingBody);
+  if (!bucketMatch || bucketMatch.index === undefined) {
+    pendingBody = `${pendingBody.trimEnd()}\n\n${bucketHeading}\n\n${renderedEntry}\n`;
+  } else {
+    const bucketBodyStart = bucketMatch.index + bucketMatch[0].length;
+    const afterBucket = pendingBody.slice(bucketBodyStart);
+    const nextBucketMatch = /^###\s+/m.exec(afterBucket);
+    const insertAt = nextBucketMatch ? bucketBodyStart + nextBucketMatch.index : pendingBody.length;
+    const beforeInsert = pendingBody.slice(0, insertAt).trimEnd();
+    const afterInsert = pendingBody.slice(insertAt).replace(/^\n+/, "");
+    pendingBody = `${beforeInsert}\n${renderedEntry}\n\n${afterInsert}`;
+  }
+
+  content = `${content.slice(0, pendingSection.bodyStart)}\n${pendingBody.trim()}\n\n${content.slice(pendingSection.end).replace(/^\n+/, "")}`;
+  await writeChangelog(filePath, content);
+};
+
+export const readPendingChangelog = async (
+  filePath: string,
+  sectionName = "Pending",
+): Promise<IPendingChangelog> => {
+  const content = await ensurePendingSection(filePath, sectionName);
+  const pendingSection = findPendingSection(content, sectionName)!;
+  const block = content.slice(pendingSection.bodyStart, pendingSection.end).trim();
+  return {
+    block,
+    isEmpty: block.length === 0,
+  };
+};
+
+export const inferVersionTypeFromPending = (pendingBlock: string): "patch" | "minor" | "major" => {
+  if (/^###\s+Breaking Changes\s*$/m.test(pendingBlock)) {
+    return "major";
+  }
+  if (/^###\s+Features\s*$/m.test(pendingBlock)) {
+    return "minor";
+  }
+  return "patch";
+};
+
+export const movePendingToVersion = async (
+  filePath: string,
+  sectionName: string,
+  versionHeading: string,
+  version: string,
+  dateString: string,
+): Promise<void> => {
+  let content = await ensurePendingSection(filePath, sectionName);
+  const pendingSection = findPendingSection(content, sectionName)!;
+  const pendingBlock = content.slice(pendingSection.bodyStart, pendingSection.end).trim();
+  if (!pendingBlock) {
+    throw new Error("No pending changelog entries. Nothing to release.");
+  }
+
+  const renderedHeading = versionHeading
+    .replaceAll("{{version}}", version)
+    .replaceAll("{{date}}", dateString);
+  const nextContent = content.slice(pendingSection.end).replace(/^\n+/, "");
+  content = `${content.slice(0, pendingSection.bodyStart)}\n\n${renderedHeading}\n\n${pendingBlock}\n\n${nextContent}`;
+  await writeChangelog(filePath, content);
+};

package/ts/helpers.smartconfigmigrations.ts

@@ -0,0 +1,192 @@
+export const CURRENT_GITZONE_CLI_SCHEMA_VERSION = 2;
+
+export interface ISmartconfigMigrationResult {
+  migrated: boolean;
+  fromVersion: number;
+  toVersion: number;
+}
+
+const CLI_NAMESPACE = "@git.zone/cli";
+
+const isPlainObject = (value: unknown): value is Record<string, any> => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+
+const ensureObject = (parent: Record<string, any>, key: string): Record<string, any> => {
+  if (!isPlainObject(parent[key])) {
+    parent[key] = {};
+  }
+  return parent[key];
+};
+
+const migrateNamespaceKeys = (smartconfigJson: Record<string, any>): boolean => {
+  let migrated = false;
+  const migrations = [
+    { oldKey: "gitzone", newKey: CLI_NAMESPACE },
+    { oldKey: "tsdoc", newKey: "@git.zone/tsdoc" },
+    { oldKey: "npmdocker", newKey: "@git.zone/tsdocker" },
+    { oldKey: "npmci", newKey: "@ship.zone/szci" },
+    { oldKey: "szci", newKey: "@ship.zone/szci" },
+  ];
+
+  for (const { oldKey, newKey } of migrations) {
+    if (!isPlainObject(smartconfigJson[oldKey])) {
+      continue;
+    }
+    if (!isPlainObject(smartconfigJson[newKey])) {
+      smartconfigJson[newKey] = smartconfigJson[oldKey];
+    } else {
+      smartconfigJson[newKey] = {
+        ...smartconfigJson[oldKey],
+        ...smartconfigJson[newKey],
+      };
+    }
+    delete smartconfigJson[oldKey];
+    migrated = true;
+  }
+
+  return migrated;
+};
+
+const migrateToV2 = (smartconfigJson: Record<string, any>): boolean => {
+  const cliConfig = ensureObject(smartconfigJson, CLI_NAMESPACE);
+  const releaseConfig = ensureObject(cliConfig, "release");
+
+  let migrated = false;
+  const targets = ensureObject(releaseConfig, "targets");
+  const shipzoneConfig = smartconfigJson["@ship.zone/szci"];
+
+  if (isPlainObject(releaseConfig.git) && !isPlainObject(targets.git)) {
+    targets.git = releaseConfig.git;
+    delete releaseConfig.git;
+    migrated = true;
+  }
+
+  if (isPlainObject(releaseConfig.npm) && !isPlainObject(targets.npm)) {
+    targets.npm = releaseConfig.npm;
+    delete releaseConfig.npm;
+    migrated = true;
+  }
+
+  if (isPlainObject(releaseConfig.docker) && !isPlainObject(targets.docker)) {
+    targets.docker = releaseConfig.docker;
+    delete releaseConfig.docker;
+    migrated = true;
+  }
+
+  if (Array.isArray(releaseConfig.registries)) {
+    const npmTarget = ensureObject(targets, "npm");
+    if (!Array.isArray(npmTarget.registries)) {
+      npmTarget.registries = releaseConfig.registries;
+    }
+    delete releaseConfig.registries;
+    migrated = true;
+  }
+
+  if (releaseConfig.accessLevel) {
+    const npmTarget = ensureObject(targets, "npm");
+    if (!npmTarget.accessLevel) {
+      npmTarget.accessLevel = releaseConfig.accessLevel;
+    }
+    delete releaseConfig.accessLevel;
+    migrated = true;
+  }
+
+  if (isPlainObject(shipzoneConfig)) {
+    if (shipzoneConfig.npmAccessLevel) {
+      const npmTarget = ensureObject(targets, "npm");
+      if (!npmTarget.accessLevel) {
+        npmTarget.accessLevel = shipzoneConfig.npmAccessLevel;
+      }
+      delete shipzoneConfig.npmAccessLevel;
+      migrated = true;
+    }
+
+    if (shipzoneConfig.npmRegistryUrl) {
+      const npmTarget = ensureObject(targets, "npm");
+      const registry = normalizeRegistryUrl(shipzoneConfig.npmRegistryUrl);
+      const registries = Array.isArray(npmTarget.registries) ? npmTarget.registries : [];
+      if (!registries.includes(registry)) {
+        registries.push(registry);
+      }
+      npmTarget.registries = registries;
+      delete shipzoneConfig.npmRegistryUrl;
+      migrated = true;
+    }
+  }
+
+  if (Array.isArray(releaseConfig.steps)) {
+    const steps = releaseConfig.steps as string[];
+    const preflight = ensureObject(releaseConfig, "preflight");
+    if (steps.includes("test") && preflight.test === undefined) {
+      preflight.test = true;
+    }
+    if (steps.includes("build") && preflight.build === undefined) {
+      preflight.build = true;
+    }
+    if (steps.includes("push")) {
+      const gitTarget = ensureObject(targets, "git");
+      if (gitTarget.enabled === undefined) {
+        gitTarget.enabled = true;
+      }
+    }
+    if (steps.includes("publishNpm")) {
+      const npmTarget = ensureObject(targets, "npm");
+      if (npmTarget.enabled === undefined) {
+        npmTarget.enabled = true;
+      }
+    }
+    if (steps.includes("publishDocker")) {
+      const dockerTarget = ensureObject(targets, "docker");
+      if (dockerTarget.enabled === undefined) {
+        dockerTarget.enabled = true;
+      }
+    }
+    delete releaseConfig.steps;
+    migrated = true;
+  }
+
+  if (releaseConfig.changelog) {
+    delete releaseConfig.changelog;
+    migrated = true;
+  }
+
+  cliConfig.schemaVersion = 2;
+  return migrated || true;
+};
+
+const normalizeRegistryUrl = (url: string): string => {
+  let normalizedUrl = url.trim();
+  if (!normalizedUrl.startsWith("http://") && !normalizedUrl.startsWith("https://")) {
+    normalizedUrl = `https://${normalizedUrl}`;
+  }
+  return normalizedUrl.endsWith("/") ? normalizedUrl.slice(0, -1) : normalizedUrl;
+};
+
+export const migrateSmartconfigData = (
+  smartconfigJson: Record<string, any>,
+  targetVersion = CURRENT_GITZONE_CLI_SCHEMA_VERSION,
+): ISmartconfigMigrationResult => {
+  let migrated = false;
+  migrated = migrateNamespaceKeys(smartconfigJson) || migrated;
+
+  const cliConfig = ensureObject(smartconfigJson, CLI_NAMESPACE);
+  const fromVersion = typeof cliConfig.schemaVersion === "number" ? cliConfig.schemaVersion : 1;
+  let currentVersion = fromVersion;
+
+  if (currentVersion < 2 && targetVersion >= 2) {
+    migrated = migrateToV2(smartconfigJson) || migrated;
+    currentVersion = 2;
+  }
+
+  if (targetVersion === CURRENT_GITZONE_CLI_SCHEMA_VERSION && cliConfig.schemaVersion !== targetVersion) {
+    cliConfig.schemaVersion = targetVersion;
+    migrated = true;
+  }
+
+  return {
+    migrated,
+    fromVersion,
+    toVersion: Math.min(targetVersion, CURRENT_GITZONE_CLI_SCHEMA_VERSION),
+  };
+};