@git.zone/cli 2.9.2 → 2.10.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@git.zone/cli",
   "private": false,
-  "version": "2.9.2",
+  "version": "2.10.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.",
   "main": "dist_ts/index.ts",
   "typings": "dist_ts/index.d.ts",
@@ -10,6 +10,24 @@
     "gitzone": "./cli.js",
     "gzone": "./cli.js"
   },
+  "scripts": {
+    "test": "(npm run clean && npm run prepareTest && npm run testCli && npm run testFormat && npm run testCommit && npm run testDeprecate && npm run testVersion && npm run testReadme && npm run testUpdate && npm run testTemplateNpm && npm run testTemplateLit) && rm -rf test",
+    "build": "tsbuild tsfolders",
+    "clean": "(rm -rf test/)",
+    "prepareTest": "(git clone https://gitlab.com/sandboxzone/sandbox-npmts.git test/)",
+    "testBuild": "npm run build && rm -r dist/",
+    "testCli": "(cd test && node ../cli.ts.js)",
+    "testCommit": "(cd test && node ../cli.ts.js commit)",
+    "testDeprecate": "(cd test && node ../cli.ts.js deprecate)",
+    "testOpen": "(cd test && node ../cli.ts.js open ci)",
+    "testReadme": "(cd test && node ../cli.ts.js readme)",
+    "testFormat": "(cd test && node ../cli.ts.js format)",
+    "testTemplateNpm": "(rm -rf test/testtemplate_npm/ && mkdir test/testtemplate_npm && cd test/testtemplate_npm && node ../../cli.ts.js template npm)",
+    "testTemplateLit": "(rm -rf test/testtemplate_lit/ && mkdir test/testtemplate_lit && cd test/testtemplate_lit && node ../../cli.ts.js template lit)",
+    "testUpdate": "(cd test && node ../cli.ts.js update)",
+    "testVersion": "(cd test && node ../cli.ts.js -v)",
+    "buildDocs": "tsdoc"
+  },
   "repository": {
     "type": "git",
     "url": "https://gitlab.com/gitzone/private/gitzone.git"
@@ -95,22 +113,14 @@
   "browserslist": [
     "last 1 chrome versions"
   ],
-  "scripts": {
-    "test": "(npm run clean && npm run prepareTest && npm run testCli && npm run testFormat && npm run testCommit && npm run testDeprecate && npm run testVersion && npm run testReadme && npm run testUpdate && npm run testTemplateNpm && npm run testTemplateLit) && rm -rf test",
-    "build": "tsbuild tsfolders",
-    "clean": "(rm -rf test/)",
-    "prepareTest": "(git clone https://gitlab.com/sandboxzone/sandbox-npmts.git test/)",
-    "testBuild": "npm run build && rm -r dist/",
-    "testCli": "(cd test && node ../cli.ts.js)",
-    "testCommit": "(cd test && node ../cli.ts.js commit)",
-    "testDeprecate": "(cd test && node ../cli.ts.js deprecate)",
-    "testOpen": "(cd test && node ../cli.ts.js open ci)",
-    "testReadme": "(cd test && node ../cli.ts.js readme)",
-    "testFormat": "(cd test && node ../cli.ts.js format)",
-    "testTemplateNpm": "(rm -rf test/testtemplate_npm/ && mkdir test/testtemplate_npm && cd test/testtemplate_npm && node ../../cli.ts.js template npm)",
-    "testTemplateLit": "(rm -rf test/testtemplate_lit/ && mkdir test/testtemplate_lit && cd test/testtemplate_lit && node ../../cli.ts.js template lit)",
-    "testUpdate": "(cd test && node ../cli.ts.js update)",
-    "testVersion": "(cd test && node ../cli.ts.js -v)",
-    "buildDocs": "tsdoc"
-  }
-}
+  "pnpm": {
+    "overrides": {},
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "mongodb-memory-server",
+      "puppeteer",
+      "sharp"
+    ]
+  },
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
+}

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/cli',
-  version: '2.9.0',
+  version: '2.10.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/mod_format/formatters/copy.formatter.ts

@@ -1,8 +1,117 @@
-import { LegacyFormatter } from './legacy.formatter.js';
-import * as formatCopy from '../format.copy.js';
+import { BaseFormatter } from '../classes.baseformatter.js';
+import type { IPlannedChange } from '../interfaces.format.js';
+import * as plugins from '../mod.plugins.js';
+import { logger, logVerbose } from '../../gitzone.logging.js';
 
-export class CopyFormatter extends LegacyFormatter {
-  constructor(context: any, project: any) {
-    super(context, project, 'copy', formatCopy);
+interface ICopyPattern {
+  from: string;
+  to: string;
+  preservePath?: boolean;
+}
+
+export class CopyFormatter extends BaseFormatter {
+  get name(): string {
+    return 'copy';
+  }
+
+  async analyze(): Promise<IPlannedChange[]> {
+    const changes: IPlannedChange[] = [];
+
+    // Get copy configuration from npmextra.json
+    const npmextraConfig = new plugins.npmextra.Npmextra();
+    const copyConfig = npmextraConfig.dataFor<{ patterns: ICopyPattern[] }>(
+      'gitzone.format.copy',
+      { patterns: [] },
+    );
+
+    if (!copyConfig.patterns || copyConfig.patterns.length === 0) {
+      logVerbose('No copy patterns configured in npmextra.json');
+      return changes;
+    }
+
+    for (const pattern of copyConfig.patterns) {
+      if (!pattern.from || !pattern.to) {
+        logVerbose('Invalid copy pattern - missing "from" or "to" field');
+        continue;
+      }
+
+      try {
+        // Handle glob patterns
+        const entries = await plugins.smartfs
+          .directory('.')
+          .recursive()
+          .filter(pattern.from)
+          .list();
+        const files = entries.map((entry) => entry.path);
+
+        for (const file of files) {
+          const sourcePath = file;
+          let destPath = pattern.to;
+
+          // If destination is a directory, preserve filename
+          if (pattern.to.endsWith('/')) {
+            const filename = plugins.path.basename(file);
+            destPath = plugins.path.join(pattern.to, filename);
+          }
+
+          // Handle template variables in destination path
+          if (pattern.preservePath) {
+            const relativePath = plugins.path.relative(
+              plugins.path.dirname(pattern.from.replace(/\*/g, '')),
+              file,
+            );
+            destPath = plugins.path.join(pattern.to, relativePath);
+          }
+
+          // Read source content
+          const content = (await plugins.smartfs
+            .file(sourcePath)
+            .encoding('utf8')
+            .read()) as string;
+
+          // Check if destination exists and has same content
+          let needsCopy = true;
+          const destExists = await plugins.smartfs.file(destPath).exists();
+          if (destExists) {
+            const existingContent = (await plugins.smartfs
+              .file(destPath)
+              .encoding('utf8')
+              .read()) as string;
+            if (existingContent === content) {
+              needsCopy = false;
+            }
+          }
+
+          if (needsCopy) {
+            changes.push({
+              type: destExists ? 'modify' : 'create',
+              path: destPath,
+              module: this.name,
+              description: `Copy from ${sourcePath}`,
+              content: content,
+            });
+          }
+        }
+      } catch (error) {
+        logVerbose(`Failed to process pattern ${pattern.from}: ${error.message}`);
+      }
+    }
+
+    return changes;
+  }
+
+  async applyChange(change: IPlannedChange): Promise<void> {
+    if (!change.content) return;
+
+    // Ensure destination directory exists
+    const destDir = plugins.path.dirname(change.path);
+    await plugins.smartfs.directory(destDir).recursive().create();
+
+    if (change.type === 'create') {
+      await this.createFile(change.path, change.content);
+    } else {
+      await this.modifyFile(change.path, change.content);
+    }
+    logger.log('info', `Copied to ${change.path}`);
   }
 }

package/ts/mod_format/formatters/gitignore.formatter.ts

@@ -1,8 +1,111 @@
-import { LegacyFormatter } from './legacy.formatter.js';
-import * as formatGitignore from '../format.gitignore.js';
+import { BaseFormatter } from '../classes.baseformatter.js';
+import type { IPlannedChange } from '../interfaces.format.js';
+import * as plugins from '../mod.plugins.js';
+import { logger } from '../../gitzone.logging.js';
 
-export class GitignoreFormatter extends LegacyFormatter {
-  constructor(context: any, project: any) {
-    super(context, project, 'gitignore', formatGitignore);
+// Standard gitignore template content (without front-matter)
+const GITIGNORE_TEMPLATE = `.nogit/
+
+# artifacts
+coverage/
+public/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# AI
+.claude/
+.serena/
+
+#------# custom`;
+
+export class GitignoreFormatter extends BaseFormatter {
+  get name(): string {
+    return 'gitignore';
+  }
+
+  async analyze(): Promise<IPlannedChange[]> {
+    const changes: IPlannedChange[] = [];
+    const gitignorePath = '.gitignore';
+
+    // Check if file exists and extract custom content
+    let customContent = '';
+    const exists = await plugins.smartfs.file(gitignorePath).exists();
+
+    if (exists) {
+      const existingContent = (await plugins.smartfs
+        .file(gitignorePath)
+        .encoding('utf8')
+        .read()) as string;
+
+      // Extract custom section content
+      const customMarkers = ['#------# custom', '# custom'];
+      for (const marker of customMarkers) {
+        const splitResult = existingContent.split(marker);
+        if (splitResult.length > 1) {
+          customContent = splitResult[1].trim();
+          break;
+        }
+      }
+    }
+
+    // Compute new content
+    let newContent = GITIGNORE_TEMPLATE;
+    if (customContent) {
+      newContent = GITIGNORE_TEMPLATE + '\n' + customContent + '\n';
+    } else {
+      newContent = GITIGNORE_TEMPLATE + '\n';
+    }
+
+    // Read current content to compare
+    let currentContent = '';
+    if (exists) {
+      currentContent = (await plugins.smartfs
+        .file(gitignorePath)
+        .encoding('utf8')
+        .read()) as string;
+    }
+
+    // Determine change type
+    if (!exists) {
+      changes.push({
+        type: 'create',
+        path: gitignorePath,
+        module: this.name,
+        description: 'Create .gitignore',
+        content: newContent,
+      });
+    } else if (newContent !== currentContent) {
+      changes.push({
+        type: 'modify',
+        path: gitignorePath,
+        module: this.name,
+        description: 'Update .gitignore (preserving custom section)',
+        content: newContent,
+      });
+    }
+
+    return changes;
+  }
+
+  async applyChange(change: IPlannedChange): Promise<void> {
+    if (!change.content) return;
+
+    if (change.type === 'create') {
+      await this.createFile(change.path, change.content);
+      logger.log('info', 'Created .gitignore');
+    } else if (change.type === 'modify') {
+      await this.modifyFile(change.path, change.content);
+      logger.log('info', 'Updated .gitignore (preserved custom section)');
+    }
   }
 }

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

@@ -1,8 +1,62 @@
-import { LegacyFormatter } from './legacy.formatter.js';
-import * as formatLicense from '../format.license.js';
+import { BaseFormatter } from '../classes.baseformatter.js';
+import type { IPlannedChange } from '../interfaces.format.js';
+import * as plugins from '../mod.plugins.js';
+import * as paths from '../../paths.js';
+import { logger } from '../../gitzone.logging.js';
 
-export class LicenseFormatter extends LegacyFormatter {
-  constructor(context: any, project: any) {
-    super(context, project, 'license', formatLicense);
+const INCOMPATIBLE_LICENSES: string[] = ['AGPL', 'GPL', 'SSPL'];
+
+export class LicenseFormatter extends BaseFormatter {
+  get name(): string {
+    return 'license';
+  }
+
+  async analyze(): Promise<IPlannedChange[]> {
+    // License formatter only checks for incompatible licenses
+    // It does not modify any files, so return empty array
+    // The actual check happens in execute() for reporting purposes
+    return [];
+  }
+
+  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) {
+        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 {
+        logger.log('error', 'License check failed - incompatible licenses found:');
+        for (const failedModule of licenseCheckResult.failingModules) {
+          console.log(
+            `  ${failedModule.name} has license ${failedModule.license}`,
+          );
+        }
+      }
+    } finally {
+      this.stats.endModule(this.name, startTime);
+    }
+  }
+
+  async applyChange(change: IPlannedChange): Promise<void> {
+    // No file changes for license formatter
   }
 }

package/ts/mod_format/formatters/npmextra.formatter.ts

@@ -1,8 +1,165 @@
-import { LegacyFormatter } from './legacy.formatter.js';
-import * as formatNpmextra from '../format.npmextra.js';
+import { BaseFormatter } from '../classes.baseformatter.js';
+import type { IPlannedChange } from '../interfaces.format.js';
+import * as plugins from '../mod.plugins.js';
+import { logger, logVerbose } from '../../gitzone.logging.js';
 
-export class NpmextraFormatter extends LegacyFormatter {
-  constructor(context: any, project: any) {
-    super(context, project, 'npmextra', formatNpmextra);
+/**
+ * Migrates npmextra.json from old namespace keys to new package-scoped keys
+ */
+const migrateNamespaceKeys = (npmextraJson: any): boolean => {
+  let migrated = false;
+  const migrations = [
+    { oldKey: 'gitzone', newKey: '@git.zone/cli' },
+    { 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 (npmextraJson[oldKey] && !npmextraJson[newKey]) {
+      npmextraJson[newKey] = npmextraJson[oldKey];
+      delete npmextraJson[oldKey];
+      migrated = true;
+    }
+  }
+  return migrated;
+};
+
+/**
+ * Migrates npmAccessLevel from @ship.zone/szci to @git.zone/cli.release.accessLevel
+ */
+const migrateAccessLevel = (npmextraJson: any): boolean => {
+  const szciConfig = npmextraJson['@ship.zone/szci'];
+
+  if (!szciConfig?.npmAccessLevel) {
+    return false;
+  }
+
+  const gitzoneConfig = npmextraJson['@git.zone/cli'] || {};
+  if (gitzoneConfig?.release?.accessLevel) {
+    delete szciConfig.npmAccessLevel;
+    return true;
+  }
+
+  if (!npmextraJson['@git.zone/cli']) {
+    npmextraJson['@git.zone/cli'] = {};
+  }
+  if (!npmextraJson['@git.zone/cli'].release) {
+    npmextraJson['@git.zone/cli'].release = {};
+  }
+
+  npmextraJson['@git.zone/cli'].release.accessLevel = szciConfig.npmAccessLevel;
+  delete szciConfig.npmAccessLevel;
+
+  return true;
+};
+
+export class NpmextraFormatter extends BaseFormatter {
+  get name(): string {
+    return 'npmextra';
+  }
+
+  async analyze(): Promise<IPlannedChange[]> {
+    const changes: IPlannedChange[] = [];
+    const npmextraPath = 'npmextra.json';
+
+    // Check if file exists
+    const exists = await plugins.smartfs.file(npmextraPath).exists();
+    if (!exists) {
+      logVerbose('npmextra.json does not exist, skipping');
+      return changes;
+    }
+
+    // Read current content
+    const currentContent = (await plugins.smartfs
+      .file(npmextraPath)
+      .encoding('utf8')
+      .read()) as string;
+
+    // Parse and compute new content
+    const npmextraJson = JSON.parse(currentContent);
+
+    // Apply migrations (these are automatic, non-interactive)
+    migrateNamespaceKeys(npmextraJson);
+    migrateAccessLevel(npmextraJson);
+
+    // Ensure namespaces exist
+    if (!npmextraJson['@git.zone/cli']) {
+      npmextraJson['@git.zone/cli'] = {};
+    }
+    if (!npmextraJson['@ship.zone/szci']) {
+      npmextraJson['@ship.zone/szci'] = {};
+    }
+
+    const newContent = JSON.stringify(npmextraJson, null, 2);
+
+    // Only add change if content differs
+    if (newContent !== currentContent) {
+      changes.push({
+        type: 'modify',
+        path: npmextraPath,
+        module: this.name,
+        description: 'Migrate and format npmextra.json',
+        content: newContent,
+      });
+    }
+
+    return changes;
+  }
+
+  async applyChange(change: IPlannedChange): Promise<void> {
+    if (change.type !== 'modify' || !change.content) return;
+
+    // Parse the content to check for missing required fields
+    const npmextraJson = JSON.parse(change.content);
+
+    // Check for missing required module information
+    const expectedRepoInformation: string[] = [
+      'projectType',
+      'module.githost',
+      'module.gitscope',
+      'module.gitrepo',
+      'module.description',
+      'module.npmPackagename',
+      'module.license',
+    ];
+
+    const interactInstance = new plugins.smartinteract.SmartInteract();
+    for (const expectedRepoInformationItem of expectedRepoInformation) {
+      if (
+        !plugins.smartobject.smartGet(
+          npmextraJson['@git.zone/cli'],
+          expectedRepoInformationItem,
+        )
+      ) {
+        interactInstance.addQuestions([
+          {
+            message: `What is the value of ${expectedRepoInformationItem}`,
+            name: expectedRepoInformationItem,
+            type: 'input',
+            default: 'undefined variable',
+          },
+        ]);
+      }
+    }
+
+    const answerbucket = await interactInstance.runQueue();
+    for (const expectedRepoInformationItem of expectedRepoInformation) {
+      const cliProvidedValue = answerbucket.getAnswerFor(
+        expectedRepoInformationItem,
+      );
+      if (cliProvidedValue) {
+        plugins.smartobject.smartAdd(
+          npmextraJson['@git.zone/cli'],
+          expectedRepoInformationItem,
+          cliProvidedValue,
+        );
+      }
+    }
+
+    // Write the final content
+    const finalContent = JSON.stringify(npmextraJson, null, 2);
+    await this.modifyFile(change.path, finalContent);
+    logger.log('info', 'Updated npmextra.json');
   }
 }