@git.zone/cli 2.19.0 → 2.19.2

package/ts/helpers.climode.ts

@@ -88,6 +88,41 @@ const parseRawArgv = (argv: string[]): TArgSource => {
   return parsedArgv;
 };
 
+export const parseCliArgv = parseRawArgv;
+
+export const getProcessUserArgv = (): string[] => {
+  const rawArgv = process.argv;
+  const argv0Base = (rawArgv[0] || "").split(/[\\/]/).pop()?.toLowerCase();
+  const runtimeNames = new Set([
+    "node",
+    "node.exe",
+    "nodejs",
+    "nodejs.exe",
+    "bun",
+    "bun.exe",
+    "deno",
+    "deno.exe",
+    "tsx",
+    "tsx.exe",
+    "ts-node",
+    "ts-node.exe",
+  ]);
+
+  if (!runtimeNames.has(argv0Base || "")) {
+    return rawArgv.slice();
+  }
+
+  const firstUserArg = rawArgv[1] || "";
+  const firstUserArgLooksLikeScript =
+    firstUserArg.includes("/") ||
+    firstUserArg.endsWith(".js") ||
+    firstUserArg.endsWith(".ts") ||
+    firstUserArg.endsWith(".mjs") ||
+    firstUserArg.endsWith(".cjs");
+
+  return rawArgv.slice(firstUserArgLooksLikeScript ? 2 : 1);
+};
+
 const normalizeOutputMode = (value: unknown): TCliOutputMode | undefined => {
   if (value === "human" || value === "plain" || value === "json") {
     return value;
@@ -171,7 +206,7 @@ export const getCliMode = async (
 
 export const getRawCliMode = async (): Promise<ICliMode> => {
   const cliConfig = await getCliModeConfig();
-  const rawArgv = parseRawArgv(process.argv.slice(2));
+  const rawArgv = parseRawArgv(getProcessUserArgv());
   return resolveCliMode(rawArgv, cliConfig);
 };
 

package/ts/helpers.smartconfigmigrations.ts

@@ -19,6 +19,38 @@ const ensureObject = (parent: Record<string, any>, key: string): Record<string,
   return parent[key];
 };
 
+const normalizeRegistryList = (registries: unknown[]): string[] => {
+  const result: string[] = [];
+  for (const registry of registries) {
+    if (typeof registry !== "string" || !registry.trim()) {
+      continue;
+    }
+    const normalizedRegistry = normalizeRegistryUrl(registry);
+    if (!result.includes(normalizedRegistry)) {
+      result.push(normalizedRegistry);
+    }
+  }
+  return result;
+};
+
+const migrateLegacyReleaseArray = (smartconfigJson: Record<string, any>): boolean => {
+  const cliConfig = ensureObject(smartconfigJson, CLI_NAMESPACE);
+  if (!Array.isArray(cliConfig.release)) {
+    return false;
+  }
+
+  const registries = normalizeRegistryList(cliConfig.release);
+  cliConfig.release = {
+    targets: {
+      npm: {
+        enabled: registries.length > 0,
+        registries,
+      },
+    },
+  };
+  return true;
+};
+
 const migrateNamespaceKeys = (smartconfigJson: Record<string, any>): boolean => {
   let migrated = false;
   const migrations = [
@@ -50,9 +82,9 @@ const migrateNamespaceKeys = (smartconfigJson: Record<string, any>): boolean =>
 
 const migrateToV2 = (smartconfigJson: Record<string, any>): boolean => {
   const cliConfig = ensureObject(smartconfigJson, CLI_NAMESPACE);
+  let migrated = migrateLegacyReleaseArray(smartconfigJson);
   const releaseConfig = ensureObject(cliConfig, "release");
 
-  let migrated = false;
   const targets = ensureObject(releaseConfig, "targets");
   const shipzoneConfig = smartconfigJson["@ship.zone/szci"];
 
@@ -192,6 +224,10 @@ export const migrateSmartconfigData = (
   const fromVersion = typeof cliConfig.schemaVersion === "number" ? cliConfig.schemaVersion : 1;
   let currentVersion = fromVersion;
 
+  if (targetVersion >= 2) {
+    migrated = migrateLegacyReleaseArray(smartconfigJson) || migrated;
+  }
+
   if (currentVersion < 2 && targetVersion >= 2) {
     migrated = migrateToV2(smartconfigJson) || migrated;
     currentVersion = 2;

package/ts/mod_config/index.ts

@@ -168,7 +168,7 @@ async function handleInteractiveMenu(): Promise<void> {
       { name: "Configure release workflow", value: "release" },
       { name: "Configure services", value: "services" },
       { name: "Validate configuration (doctor)", value: "doctor" },
-      { name: "Fix configuration with opencode", value: "fix" },
+      { name: "Fix configuration", value: "fix" },
       { name: "Add an npm target registry", value: "add" },
       { name: "Remove an npm target registry", value: "remove" },
       { name: "Clear npm target registries", value: "clear" },
@@ -939,8 +939,8 @@ async function handleFix(argvArg: any, mode: ICliMode): Promise<void> {
     return;
   }
 
-  const findings = await collectDoctorFindings();
-  const counts = countDoctorFindings(findings);
+  let findings = await collectDoctorFindings();
+  let counts = countDoctorFindings(findings);
   const extraInstructions = (argvArg._?.slice(2).join(" ") || "").trim();
   const force = Boolean(argvArg.force);
 
@@ -954,10 +954,10 @@ async function handleFix(argvArg: any, mode: ICliMode): Promise<void> {
 
   if (!mode.yes) {
     if (!mode.interactive) {
-      throw new Error("Config fix requires an interactive terminal or `-y` to run opencode non-interactively.");
+      throw new Error("Config fix requires an interactive terminal or `-y` to run non-interactively.");
     }
     const confirmed = await plugins.smartinteract.SmartInteract.getCliConfirmation(
-      `Run opencode to fix .smartconfig.json? (${counts.error} error, ${counts.warn} warning)`,
+      `Run configuration fixes for .smartconfig.json? (${counts.error} error, ${counts.warn} warning)`,
       true,
     );
     if (!confirmed) {
@@ -966,6 +966,16 @@ async function handleFix(argvArg: any, mode: ICliMode): Promise<void> {
     }
   }
 
+  const appliedKnownFixes = await applyKnownConfigFixes(mode);
+  if (appliedKnownFixes) {
+    findings = await collectDoctorFindings();
+    counts = countDoctorFindings(findings);
+    if (counts.error === 0 && counts.warn === 0 && !extraInstructions && !force) {
+      printDoctorResult(findings, mode);
+      return;
+    }
+  }
+
   const opencodeArgs = [
     "run",
     "--title",
@@ -1004,6 +1014,33 @@ async function handleFix(argvArg: any, mode: ICliMode): Promise<void> {
   printDoctorResult(finalFindings, mode);
 }
 
+async function applyKnownConfigFixes(mode: ICliMode): Promise<boolean> {
+  const smartconfigPath = getSmartconfigPath();
+  if (!(await plugins.smartfs.file(smartconfigPath).exists())) {
+    return false;
+  }
+
+  let smartconfigData: Record<string, any>;
+  try {
+    smartconfigData = await readSmartconfigFile();
+  } catch {
+    return false;
+  }
+
+  const result = migrateSmartconfigData(smartconfigData);
+  if (!result.migrated) {
+    return false;
+  }
+
+  await writeSmartconfigFile(smartconfigData);
+  plugins.logger.log(
+    "success",
+    `Applied known .smartconfig.json migrations to schema v${result.toVersion}`,
+  );
+  await formatSmartconfigWithDiff(mode);
+  return true;
+}
+
 async function collectDoctorFindings(): Promise<IDoctorFinding[]> {
   const findings: IDoctorFinding[] = [];
   const smartconfigPath = getSmartconfigPath();
@@ -1071,7 +1108,7 @@ async function collectDoctorFindings(): Promise<IDoctorFinding[]> {
   await validateDetectedProjectType(cliConfig, findings);
 
   validateCommitConfig(cliConfig.commit || {}, findings);
-  await validateReleaseConfig(cliConfig.release || {}, smartconfigData, findings);
+  await validateReleaseConfig(cliConfig.release, smartconfigData, findings);
 
   return findings;
 }
@@ -1570,10 +1607,24 @@ function validateCommitConfig(
 }
 
 async function validateReleaseConfig(
-  releaseConfig: Record<string, any>,
+  rawReleaseConfig: unknown,
   smartconfigData: Record<string, any>,
   findings: IDoctorFinding[],
 ): Promise<void> {
+  const releaseConfig = rawReleaseConfig === undefined ? {} : rawReleaseConfig;
+  if (!isPlainObject(releaseConfig)) {
+    findings.push({
+      level: "error",
+      message: `Release config must be an object, found ${
+        Array.isArray(releaseConfig) ? "array" : typeof releaseConfig
+      }`,
+      fix: Array.isArray(releaseConfig)
+        ? "Run `gitzone config migrate` to move legacy registry arrays into release.targets.npm.registries."
+        : "Set @git.zone/cli.release to an object or remove it.",
+    });
+    return;
+  }
+
   const confirmation = releaseConfig.confirmation;
   if (confirmation === undefined || validConfirmationModes.includes(confirmation)) {
     findings.push({ level: "ok", message: "Release confirmation mode is valid" });
@@ -1993,7 +2044,7 @@ export function showHelp(mode?: ICliMode): void {
         { name: "cli", description: "Configure CLI behavior interactively" },
         { name: "release", description: "Configure release workflow interactively" },
         { name: "doctor", description: "Validate .smartconfig.json" },
-        { name: "fix [instructions]", description: "Use opencode to repair .smartconfig.json" },
+        { name: "fix [instructions]", description: "Repair .smartconfig.json" },
         { name: "get <path>", description: "Read a single config value" },
         { name: "set <path> <value>", description: "Write a config value" },
         { name: "unset <path>", description: "Delete a config value" },
@@ -2038,7 +2089,7 @@ export function showHelp(mode?: ICliMode): void {
   console.log("  cli                         Configure CLI behavior interactively");
   console.log("  release                     Configure release workflow interactively");
   console.log("  doctor                      Validate .smartconfig.json");
-  console.log("  fix [instructions]          Use opencode to repair .smartconfig.json");
+  console.log("  fix [instructions]          Repair .smartconfig.json");
   console.log("  get <path>                  Read a single config value");
   console.log("  set <path> <value>          Write a config value");
   console.log("  unset <path>                Delete a config value");

package/ts/mod_format/classes.baseformatter.ts

@@ -1,6 +1,10 @@
 import * as plugins from './mod.plugins.js';
 import { FormatContext } from './classes.formatcontext.js';
-import type { IPlannedChange, ICheckResult } from './interfaces.format.js';
+import type {
+  IPlannedChange,
+  ICheckResult,
+  IFormatWarning,
+} from './interfaces.format.js';
 import { Project } from '../classes.project.js';
 import { FormatStats } from './classes.formatstats.js';
 
@@ -19,6 +23,14 @@ export abstract class BaseFormatter {
   abstract analyze(): Promise<IPlannedChange[]>;
   abstract applyChange(change: IPlannedChange): Promise<void>;
 
+  get runsWithoutChanges(): boolean {
+    return false;
+  }
+
+  async validate(): Promise<IFormatWarning[]> {
+    return [];
+  }
+
   async execute(changes: IPlannedChange[]): Promise<void> {
     const startTime = this.stats.moduleStartTime(this.name);
     this.stats.startModule(this.name);

package/ts/mod_format/classes.formatplanner.ts

@@ -1,7 +1,11 @@
 import * as plugins from './mod.plugins.js';
 import { FormatContext } from './classes.formatcontext.js';
 import { BaseFormatter } from './classes.baseformatter.js';
-import type { IFormatPlan, IPlannedChange } from './interfaces.format.js';
+import type {
+  IFormatPlan,
+  IPlannedChange,
+  IFormatWarning,
+} from './interfaces.format.js';
 import { getModuleIcon } from './interfaces.format.js';
 import { logger } from '../gitzone.logging.js';
 import { DiffReporter } from './classes.diffreporter.js';
@@ -42,15 +46,21 @@ export class FormatPlanner {
               break;
           }
         }
+
+        const warnings = await module.validate();
+        plan.warnings.push(...warnings);
       } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
         plan.warnings.push({
           level: 'error',
-          message: `Failed to analyze module ${module.name}: ${error.message}`,
+          message: `Failed to analyze module ${module.name}: ${errorMessage}`,
           module: module.name,
         });
       }
     }
 
+    plan.warnings.push(...this.detectConflictingChanges(plan.changes));
+
     plan.summary.totalFiles =
       plan.summary.filesAdded +
       plan.summary.filesModified +
@@ -65,11 +75,12 @@ export class FormatPlanner {
     context: FormatContext,
   ): Promise<void> {
     const startTime = Date.now();
+    const changesByModule = this.groupChangesByModule(plan.changes);
 
     for (const module of modules) {
-      const changes = this.plannedChanges.get(module.name) || [];
+      const changes = changesByModule.get(module.name) || [];
 
-      if (changes.length > 0) {
+      if (changes.length > 0 || module.runsWithoutChanges) {
         logger.log('info', `Executing ${module.name} formatter...`);
         await module.execute(changes);
       }
@@ -138,4 +149,55 @@ export class FormatPlanner {
         return '❌';
     }
   }
+
+  private groupChangesByModule(
+    changes: IPlannedChange[],
+  ): Map<string, IPlannedChange[]> {
+    const changesByModule = new Map<string, IPlannedChange[]>();
+    for (const change of changes) {
+      const moduleChanges = changesByModule.get(change.module) || [];
+      moduleChanges.push(change);
+      changesByModule.set(change.module, moduleChanges);
+    }
+    return changesByModule;
+  }
+
+  private detectConflictingChanges(
+    changes: IPlannedChange[],
+  ): IFormatWarning[] {
+    const warnings: IFormatWarning[] = [];
+    const changesByPath = new Map<string, IPlannedChange[]>();
+
+    for (const change of changes) {
+      if (!change.path || change.path === '<various files>') {
+        continue;
+      }
+
+      const pathChanges = changesByPath.get(change.path) || [];
+      pathChanges.push(change);
+      changesByPath.set(change.path, pathChanges);
+    }
+
+    for (const [path, pathChanges] of changesByPath) {
+      const modules = [...new Set(pathChanges.map((change) => change.module))];
+      if (modules.length < 2) {
+        continue;
+      }
+
+      const hasDelete = pathChanges.some((change) => change.type === 'delete');
+      const plannedContents = pathChanges
+        .map((change) => change.content)
+        .filter((content): content is string => content !== undefined);
+      const uniqueContents = new Set(plannedContents);
+      const level = hasDelete || uniqueContents.size > 1 ? 'warning' : 'info';
+
+      warnings.push({
+        level,
+        module: 'planner',
+        message: `Multiple formatters plan changes for ${path}: ${modules.join(', ')}. They will run in formatter order.`,
+      });
+    }
+
+    return warnings;
+  }
 }

package/ts/mod_format/formatters/license.formatter.ts

@@ -1,5 +1,5 @@
 import { BaseFormatter } from '../classes.baseformatter.js';
-import type { IPlannedChange } from '../interfaces.format.js';
+import type { IFormatWarning, IPlannedChange } from '../interfaces.format.js';
 import * as plugins from '../mod.plugins.js';
 import * as paths from '../../paths.js';
 import { logger } from '../../gitzone.logging.js';
@@ -11,6 +11,10 @@ export class LicenseFormatter extends BaseFormatter {
     return 'license';
   }
 
+  get runsWithoutChanges(): boolean {
+    return true;
+  }
+
   async analyze(): Promise<IPlannedChange[]> {
     // License formatter only checks for incompatible licenses
     // It does not modify any files, so return empty array
@@ -18,29 +22,34 @@ export class LicenseFormatter extends BaseFormatter {
     return [];
   }
 
+  async validate(): Promise<IFormatWarning[]> {
+    const result = await this.checkLicenses();
+    if (!result || result.failingModules.length === 0) {
+      return [];
+    }
+
+    return [
+      {
+        level: 'error',
+        module: this.name,
+        message: `License check failed for ${result.failingModules.length} module(s): ${result.failingModules
+          .map((failedModule) => `${failedModule.name} (${failedModule.license})`)
+          .join(', ')}`,
+      },
+    ];
+  }
+
   async execute(changes: IPlannedChange[]): Promise<void> {
     const startTime = this.stats.moduleStartTime(this.name);
     this.stats.startModule(this.name);
 
     try {
-      // Check if node_modules exists
-      const nodeModulesPath = plugins.path.join(paths.cwd, 'node_modules');
-      const nodeModulesExists = await plugins.smartfs
-        .directory(nodeModulesPath)
-        .exists();
-
-      if (!nodeModulesExists) {
+      const licenseCheckResult = await this.checkLicenses();
+      if (!licenseCheckResult) {
         logger.log('warn', 'No node_modules found. Skipping license check');
         return;
       }
 
-      // Run license check
-      const licenseChecker = await plugins.smartlegal.createLicenseChecker();
-      const licenseCheckResult = await licenseChecker.excludeLicenseWithinPath(
-        paths.cwd,
-        INCOMPATIBLE_LICENSES,
-      );
-
       if (licenseCheckResult.failingModules.length === 0) {
         logger.log('info', 'License check passed - no incompatible licenses found');
       } else {
@@ -59,4 +68,23 @@ export class LicenseFormatter extends BaseFormatter {
   async applyChange(change: IPlannedChange): Promise<void> {
     // No file changes for license formatter
   }
+
+  private async checkLicenses(): Promise<{
+    failingModules: Array<{ name: string; license: string }>;
+  } | undefined> {
+    const nodeModulesPath = plugins.path.join(paths.cwd, 'node_modules');
+    const nodeModulesExists = await plugins.smartfs
+      .directory(nodeModulesPath)
+      .exists();
+
+    if (!nodeModulesExists) {
+      return undefined;
+    }
+
+    const licenseChecker = await plugins.smartlegal.createLicenseChecker();
+    return await licenseChecker.excludeLicenseWithinPath(
+      paths.cwd,
+      INCOMPATIBLE_LICENSES,
+    );
+  }
 }

package/ts/mod_format/formatters/prettier.formatter.ts

@@ -56,7 +56,8 @@ export class PrettierFormatter extends BaseFormatter {
         );
         allFiles.push(...filteredFiles);
       } catch (error) {
-        logVerbose(`Skipping directory ${dir}: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logVerbose(`Skipping directory ${dir}: ${errorMessage}`);
       }
     }
 
@@ -72,7 +73,8 @@ export class PrettierFormatter extends BaseFormatter {
         const rootLevelFiles = rootFiles.filter((f) => !f.includes('/'));
         allFiles.push(...rootLevelFiles);
       } catch (error) {
-        logVerbose(`Skipping pattern ${pattern}: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logVerbose(`Skipping pattern ${pattern}: ${errorMessage}`);
       }
     }
 
@@ -89,20 +91,46 @@ export class PrettierFormatter extends BaseFormatter {
         }
       } catch (error) {
         // Skip files that can't be accessed
-        logVerbose(`Skipping ${file} - cannot access: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logVerbose(`Skipping ${file} - cannot access: ${errorMessage}`);
       }
     }
 
+    const prettier = await import('prettier');
+    const prettierConfig = await this.getPrettierConfig();
+
     for (const file of validFiles) {
-      changes.push({
-        type: 'modify',
-        path: file,
-        module: this.name,
-        description: 'Format with Prettier',
-      });
+      try {
+        const fileExt = plugins.path.extname(file).toLowerCase();
+        if (!fileExt) {
+          continue;
+        }
+
+        const content = (await plugins.smartfs
+          .file(file)
+          .encoding('utf8')
+          .read()) as string;
+        const formatted = await prettier.format(content, {
+          filepath: file,
+          ...prettierConfig,
+        });
+
+        if (formatted !== content) {
+          changes.push({
+            type: 'modify',
+            path: file,
+            module: this.name,
+            description: 'Format with Prettier',
+            content: formatted,
+          });
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logVerbose(`Skipping Prettier analysis for ${file}: ${errorMessage}`);
+      }
     }
 
-    logger.log('info', `Found ${changes.length} files to format with Prettier`);
+    logger.log('info', `Found ${changes.length} files needing Prettier`);
     return changes;
   }
 
@@ -127,9 +155,10 @@ export class PrettierFormatter extends BaseFormatter {
           this.stats.recordFileOperation(this.name, change.type, true);
         } catch (error) {
           this.stats.recordFileOperation(this.name, change.type, false);
+          const errorMessage = error instanceof Error ? error.message : String(error);
           logger.log(
             'error',
-            `Failed to format ${change.path}: ${error.message}`,
+            `Failed to format ${change.path}: ${errorMessage}`,
           );
           // Don't throw - continue with other files
         }
@@ -192,28 +221,32 @@ export class PrettierFormatter extends BaseFormatter {
           logVerbose(`No formatting changes for ${change.path}`);
         }
       } catch (prettierError) {
+        const prettierErrorMessage = prettierError instanceof Error
+          ? prettierError.message
+          : String(prettierError);
         // Check if it's a parser error
-        if (
-          prettierError.message &&
-          prettierError.message.includes('No parser could be inferred')
-        ) {
-          logVerbose(`Skipping ${change.path} - ${prettierError.message}`);
+        if (prettierErrorMessage.includes('No parser could be inferred')) {
+          logVerbose(`Skipping ${change.path} - ${prettierErrorMessage}`);
           return; // Skip this file silently
         }
         throw prettierError;
       }
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : undefined;
       // Log the full error stack for debugging mkdir issues
-      if (error.message && error.message.includes('mkdir')) {
+      if (errorMessage.includes('mkdir')) {
         logger.log(
           'error',
-          `Failed to format ${change.path}: ${error.message}`,
+          `Failed to format ${change.path}: ${errorMessage}`,
         );
-        logger.log('error', `Error stack: ${error.stack}`);
+        if (errorStack) {
+          logger.log('error', `Error stack: ${errorStack}`);
+        }
       } else {
         logger.log(
           'error',
-          `Failed to format ${change.path}: ${error.message}`,
+          `Failed to format ${change.path}: ${errorMessage}`,
         );
       }
       throw error;
@@ -234,52 +267,7 @@ export class PrettierFormatter extends BaseFormatter {
     });
   }
 
-  /**
-   * Override check() to compute diffs on-the-fly by running prettier
-   */
   async check(): Promise<ICheckResult> {
-    const changes = await this.analyze();
-    const diffs: ICheckResult['diffs'] = [];
-
-    for (const change of changes) {
-      if (change.type !== 'modify') continue;
-
-      try {
-        // Read current content
-        const currentContent = (await plugins.smartfs
-          .file(change.path)
-          .encoding('utf8')
-          .read()) as string;
-
-        // Skip files without extension (prettier can't infer parser)
-        const fileExt = plugins.path.extname(change.path).toLowerCase();
-        if (!fileExt) continue;
-
-        // Format with prettier to get what it would produce
-        const prettier = await import('prettier');
-        const formatted = await prettier.format(currentContent, {
-          filepath: change.path,
-          ...(await this.getPrettierConfig()),
-        });
-
-        // Only add to diffs if content differs
-        if (formatted !== currentContent) {
-          diffs.push({
-            path: change.path,
-            type: 'modify',
-            before: currentContent,
-            after: formatted,
-          });
-        }
-      } catch (error) {
-        // Skip files that can't be processed
-        logVerbose(`Skipping diff for ${change.path}: ${error.message}`);
-      }
-    }
-
-    return {
-      hasDiff: diffs.length > 0,
-      diffs,
-    };
+    return await super.check();
   }
 }