update to smartconfig

ts/mod_format/index.ts

@@ -5,9 +5,8 @@ import { FormatPlanner } from './classes.formatplanner.js';
 import { BaseFormatter } from './classes.baseformatter.js';
 import { logger, setVerboseMode } from '../gitzone.logging.js';
 
-// Import wrapper classes for formatters
 import { CleanupFormatter } from './formatters/cleanup.formatter.js';
-import { NpmextraFormatter } from './formatters/npmextra.formatter.js';
+import { SmartconfigFormatter } from './formatters/smartconfig.formatter.js';
 import { LicenseFormatter } from './formatters/license.formatter.js';
 import { PackageJsonFormatter } from './formatters/packagejson.formatter.js';
 import { TemplatesFormatter } from './formatters/templates.formatter.js';
@@ -17,82 +16,66 @@ import { PrettierFormatter } from './formatters/prettier.formatter.js';
 import { ReadmeFormatter } from './formatters/readme.formatter.js';
 import { CopyFormatter } from './formatters/copy.formatter.js';
 
+// Shared formatter class map used by both run() and runFormatter()
+const formatterMap: Record<string, new (ctx: FormatContext, proj: Project) => BaseFormatter> = {
+  cleanup: CleanupFormatter,
+  smartconfig: SmartconfigFormatter,
+  license: LicenseFormatter,
+  packagejson: PackageJsonFormatter,
+  templates: TemplatesFormatter,
+  gitignore: GitignoreFormatter,
+  tsconfig: TsconfigFormatter,
+  prettier: PrettierFormatter,
+  readme: ReadmeFormatter,
+  copy: CopyFormatter,
+};
+
+// Formatters that don't require projectType to be set
+const formattersNotRequiringProjectType = ['smartconfig', 'prettier', 'cleanup', 'packagejson'];
+
 export let run = async (
   options: {
-    write?: boolean;      // Explicitly write changes (default: false, dry-mode)
-    dryRun?: boolean;     // Deprecated, kept for compatibility
+    write?: boolean;
+    dryRun?: boolean; // Deprecated, kept for compatibility
     yes?: boolean;
     planOnly?: boolean;
     savePlan?: string;
     fromPlan?: string;
     detailed?: boolean;
     interactive?: boolean;
-    parallel?: boolean;
     verbose?: boolean;
-    diff?: boolean;       // Show file diffs
+    diff?: boolean;
   } = {},
 ): Promise<any> => {
-  // Set verbose mode if requested
   if (options.verbose) {
     setVerboseMode(true);
   }
 
-  // Determine if we should write changes
-  // Default is dry-mode (no writing) unless --write/-w is specified
   const shouldWrite = options.write ?? (options.dryRun === false);
 
   const project = await Project.fromCwd({ requireProjectType: false });
   const context = new FormatContext();
-  // Cache system removed - no longer needed
   const planner = new FormatPlanner();
 
-  // Get configuration from npmextra
-  const npmextraConfig = new plugins.npmextra.Smartconfig();
-  const formatConfig = npmextraConfig.dataFor<any>('@git.zone/cli.format', {
+  const smartconfigInstance = new plugins.smartconfig.Smartconfig();
+  const formatConfig = smartconfigInstance.dataFor<any>('@git.zone/cli.format', {
     interactive: true,
     showDiffs: false,
     autoApprove: false,
-    planTimeout: 30000,
-    rollback: {
-      enabled: true,
-      autoRollbackOnError: true,
-      backupRetentionDays: 7,
-      maxBackupSize: '100MB',
-      excludePatterns: ['node_modules/**', '.git/**'],
-    },
     modules: {
       skip: [],
       only: [],
-      order: [],
-    },
-    parallel: true,
-    cache: {
-      enabled: true,
-      clean: true, // Clean invalid entries from cache
     },
   });
 
-  // Cache cleaning removed - no longer using cache system
-
-  // Override config with command options
   const interactive = options.interactive ?? formatConfig.interactive;
   const autoApprove = options.yes ?? formatConfig.autoApprove;
-  const parallel = options.parallel ?? formatConfig.parallel;
 
   try {
-    // Initialize formatters
-    const formatters = [
-      new CleanupFormatter(context, project),
-      new NpmextraFormatter(context, project),
-      new LicenseFormatter(context, project),
-      new PackageJsonFormatter(context, project),
-      new TemplatesFormatter(context, project),
-      new GitignoreFormatter(context, project),
-      new TsconfigFormatter(context, project),
-      new PrettierFormatter(context, project),
-      new ReadmeFormatter(context, project),
-      new CopyFormatter(context, project),
-    ];
+    // Initialize formatters in execution order
+    const formatters = Object.entries(formatterMap).map(
+      ([, FormatterClass]) => new FormatterClass(context, project),
+    );
 
     // Filter formatters based on configuration
     const activeFormatters = formatters.filter((formatter) => {
@@ -128,13 +111,13 @@ export let run = async (
       logger.log('info', `Plan saved to ${options.savePlan}`);
     }
 
-    // Exit if plan-only mode
     if (options.planOnly) {
       return;
     }
 
-    // Show diffs if requested (works in both dry-run and write modes)
-    if (options.diff) {
+    // Show diffs if explicitly requested or before interactive write confirmation
+    const showDiffs = options.diff || (shouldWrite && interactive && !autoApprove);
+    if (showDiffs) {
       logger.log('info', 'Showing file diffs:');
       console.log('');
 
@@ -171,22 +154,16 @@ export let run = async (
     }
 
     // Execute phase
-    logger.log(
-      'info',
-      `Executing format operations${parallel ? ' in parallel' : ' sequentially'}...`,
-    );
-    await planner.executePlan(plan, activeFormatters, context, parallel);
+    logger.log('info', 'Executing format operations...');
+    await planner.executePlan(plan, activeFormatters, context);
 
-    // Finish statistics tracking
     context.getFormatStats().finish();
 
-    // Display statistics
-    const showStats = npmextraConfig.dataFor('gitzone.format.showStats', true);
+    const showStats = smartconfigInstance.dataFor('gitzone.format.showStats', true);
     if (showStats) {
       context.getFormatStats().displayStats();
     }
 
-    // Save stats if requested
     if (options.detailed) {
       const statsPath = `.nogit/format-stats-${Date.now()}.json`;
       await context.getFormatStats().saveReport(statsPath);
@@ -195,36 +172,13 @@ export let run = async (
     logger.log('success', 'Format operations completed successfully!');
   } catch (error) {
     logger.log('error', `Format operation failed: ${error.message}`);
-
-    // Rollback system has been removed for stability
-
     throw error;
   }
 };
 
-// Export CLI command handlers
-export const handleRollback = async (operationId?: string): Promise<void> => {
-  logger.log('info', 'Rollback system has been disabled for stability');
-};
-
-export const handleListBackups = async (): Promise<void> => {
-  logger.log('info', 'Backup system has been disabled for stability');
-};
-
-export const handleCleanBackups = async (): Promise<void> => {
-  logger.log(
-    'info',
-    'Backup cleaning has been disabled - backup system removed',
-  );
-};
-
-// Import the ICheckResult type for external use
 import type { ICheckResult } from './interfaces.format.js';
 export type { ICheckResult };
 
-// Formatters that don't require projectType to be set
-const formattersNotRequiringProjectType = ['npmextra', 'prettier', 'cleanup', 'packagejson'];
-
 /**
  * Run a single formatter by name (for use by other modules)
  */
@@ -232,29 +186,14 @@ export const runFormatter = async (
   formatterName: string,
   options: {
     silent?: boolean;
-    checkOnly?: boolean;    // Only check for diffs, don't apply
-    showDiff?: boolean;     // Show the diff output
+    checkOnly?: boolean;
+    showDiff?: boolean;
   } = {}
 ): Promise<ICheckResult | void> => {
-  // Determine if this formatter requires projectType
   const requireProjectType = !formattersNotRequiringProjectType.includes(formatterName);
   const project = await Project.fromCwd({ requireProjectType });
   const context = new FormatContext();
 
-  // Map formatter names to classes
-  const formatterMap: Record<string, new (ctx: FormatContext, proj: Project) => BaseFormatter> = {
-    cleanup: CleanupFormatter,
-    npmextra: NpmextraFormatter,
-    license: LicenseFormatter,
-    packagejson: PackageJsonFormatter,
-    templates: TemplatesFormatter,
-    gitignore: GitignoreFormatter,
-    tsconfig: TsconfigFormatter,
-    prettier: PrettierFormatter,
-    readme: ReadmeFormatter,
-    copy: CopyFormatter,
-  };
-
   const FormatterClass = formatterMap[formatterName];
   if (!FormatterClass) {
     throw new Error(`Unknown formatter: ${formatterName}`);
@@ -262,7 +201,6 @@ export const runFormatter = async (
 
   const formatter = new FormatterClass(context, project);
 
-  // Check-only mode: just check for diffs and optionally display them
   if (options.checkOnly) {
     const result = await formatter.check();
     if (result.hasDiff && options.showDiff) {
@@ -271,7 +209,6 @@ export const runFormatter = async (
     return result;
   }
 
-  // Normal mode: analyze and apply changes
   const changes = await formatter.analyze();
 
   for (const change of changes) {