feat(cli): add update command to check and update globally installed @git.zone packages

.gitignore

@@ -3,7 +3,6 @@
 # artifacts
 coverage/
 public/
-pages/
 
 # installs
 node_modules/
@@ -17,4 +16,8 @@ node_modules/
 dist/
 dist_*/
 
-# custom
+# AI
+.claude/
+.serena/
+
+#------# custom

changelog.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 2026-02-03 - 3.1.0 - feat(cli)
+add update command to check and update globally installed @git.zone packages
+
+- Adds a new mod_update module and PackageManagerUtil to detect installed @git.zone packages and fetch latest versions
+- Supports npm, yarn and pnpm: detection, listing, version comparison and executing updates
+- Interactive confirmation via @push.rocks/smartinteract with a -y flag to skip prompt
+- Uses @push.rocks/smartshell to run shell commands for listing and updating packages
+- Wires the new 'update' command into the CLI (tools.cli) and updates CLI version to 3.0.0
+- Adds CLI helper files (cli.child.js, adjusts cli.js and cli.ts.js) to run TypeScript CLI via tsrun/runPath
+- Updates package.json to include new dependencies and npmextra.json with release registries and @git.zone/cli metadata
+- Updates .gitignore to exclude local AI tool dirs (.claude, .serena)
+
 ## 2026-02-03 - 3.0.0 - BREAKING CHANGE(tools)
 replace install functionality with a minimal placeholder CLI; remove installer, logging, path utilities, and related assets
 

cli.child.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+import * as cliTool from './ts/index.js';
+cliTool.runCli();

cli.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-const cliTool = require('./dist_ts/index');
+const cliTool = await import('./dist_ts/index.js');
 cliTool.runCli();

cli.ts.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-require('@git.zone/tsrun');
-const cliTool = require('./ts/index');
-cliTool.runCli();
+
+import * as tsrun from '@git.zone/tsrun';
+tsrun.runPath('./cli.child.js', import.meta.url);

npmextra.json

@@ -2,13 +2,7 @@
   "npmts": {
     "cli": true
   },
-  "npmci": {
-    "globalNpmTools": [
-      "npmts"
-    ],
-    "npmAccessLevel": "public"
-  },
-  "gitzone": {
+  "@git.zone/cli": {
     "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
@@ -16,7 +10,20 @@
       "gitrepo": "tools",
       "shortDescription": "setup your environment with the most important tools and update them easily.",
       "npmPackagename": "@git.zone/tools",
-      "license": "MIT"
+      "license": "MIT",
+      "description": "manage git.zone tools"
+    },
+    "release": {
+      "registries": [
+        "https://verdaccio.lossless.digital",
+        "https://registry.npmjs.org"
+      ],
+      "accessLevel": "public"
     }
+  },
+  "@ship.zone/szci": {
+    "globalNpmTools": [
+      "npmts"
+    ]
   }
 }

package.json

@@ -36,6 +36,8 @@
   "dependencies": {
     "@git.zone/tsrun": "^2.0.1",
     "@push.rocks/smartcli": "^4.0.20",
+    "@push.rocks/smartinteract": "^2.0.16",
+    "@push.rocks/smartshell": "^3.3.0",
     "@types/node": "^22.0.0"
   },
   "files": [

pnpm-lock.yaml

@@ -14,6 +14,12 @@ importers:
       '@push.rocks/smartcli':
         specifier: ^4.0.20
         version: 4.0.20
+      '@push.rocks/smartinteract':
+        specifier: ^2.0.16
+        version: 2.0.16
+      '@push.rocks/smartshell':
+        specifier: ^3.3.0
+        version: 3.3.0
       '@types/node':
         specifier: ^22.0.0
         version: 22.19.8

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tools',
-  version: '3.0.0',
+  version: '3.1.0',
   description: 'A CLI tool placeholder for development utilities.'
 }

ts/mod_update/classes.packagemanager.ts

@@ -0,0 +1,193 @@
+import * as plugins from './mod.plugins.js';
+
+export type TPackageManager = 'npm' | 'yarn' | 'pnpm';
+
+export interface IInstalledPackage {
+  name: string;
+  version: string;
+  packageManager: TPackageManager;
+}
+
+export interface IPackageUpdateInfo {
+  name: string;
+  currentVersion: string;
+  latestVersion: string;
+  packageManager: TPackageManager;
+  needsUpdate: boolean;
+}
+
+export class PackageManagerUtil {
+  private shell = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+  });
+
+  /**
+   * Check if a package manager is available on the system
+   */
+  public async isAvailable(pm: TPackageManager): Promise<boolean> {
+    try {
+      const result = await this.shell.execSilent(`which ${pm} >/dev/null 2>&1 && echo "found"`);
+      return result.exitCode === 0 && result.stdout.includes('found');
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get all globally installed @git.zone packages for a package manager
+   */
+  public async getInstalledPackages(pm: TPackageManager): Promise<IInstalledPackage[]> {
+    const packages: IInstalledPackage[] = [];
+
+    try {
+      let result;
+      switch (pm) {
+        case 'npm':
+          result = await this.shell.execSilent('npm list -g --depth=0 --json 2>/dev/null || true');
+          break;
+        case 'yarn':
+          result = await this.shell.execSilent('yarn global list --depth=0 --json 2>/dev/null || true');
+          break;
+        case 'pnpm':
+          result = await this.shell.execSilent('pnpm list -g --depth=0 --json 2>/dev/null || true');
+          break;
+      }
+
+      const output = result.stdout.trim();
+      if (!output) {
+        return packages;
+      }
+
+      if (pm === 'npm') {
+        try {
+          const data = JSON.parse(output);
+          const deps = data.dependencies || {};
+          for (const [name, info] of Object.entries(deps)) {
+            if (name.startsWith('@git.zone/')) {
+              packages.push({
+                name,
+                version: (info as any).version || 'unknown',
+                packageManager: pm,
+              });
+            }
+          }
+        } catch {
+          // JSON parse failed
+        }
+      } else if (pm === 'pnpm') {
+        // pnpm returns an array of objects
+        try {
+          const data = JSON.parse(output);
+          // Handle array format from pnpm
+          const dataArray = Array.isArray(data) ? data : [data];
+          for (const item of dataArray) {
+            const deps = item.dependencies || {};
+            for (const [name, info] of Object.entries(deps)) {
+              if (name.startsWith('@git.zone/')) {
+                packages.push({
+                  name,
+                  version: (info as any).version || 'unknown',
+                  packageManager: pm,
+                });
+              }
+            }
+          }
+        } catch {
+          // JSON parse failed
+        }
+      } else if (pm === 'yarn') {
+        // Yarn global list --json outputs multiple JSON lines
+        const lines = output.split('\n').filter(l => l.trim());
+        for (const line of lines) {
+          try {
+            const data = JSON.parse(line);
+            if (data.type === 'tree' && data.data && data.data.trees) {
+              for (const tree of data.data.trees) {
+                const name = tree.name?.split('@')[0] || '';
+                if (name.startsWith('@git.zone/')) {
+                  const version = tree.name?.split('@').pop() || 'unknown';
+                  packages.push({
+                    name,
+                    version,
+                    packageManager: pm,
+                  });
+                }
+              }
+            }
+          } catch {
+            // Skip invalid JSON lines
+          }
+        }
+      }
+    } catch {
+      // Command failed, return empty array
+    }
+
+    return packages;
+  }
+
+  /**
+   * Get the latest version of a package from npm registry
+   */
+  public async getLatestVersion(packageName: string): Promise<string | null> {
+    try {
+      const result = await this.shell.execSilent(`npm view ${packageName} version 2>/dev/null`);
+      if (result.exitCode === 0 && result.stdout.trim()) {
+        return result.stdout.trim();
+      }
+    } catch {
+      // Command failed
+    }
+    return null;
+  }
+
+  /**
+   * Execute an update for a package using the specified package manager
+   */
+  public async executeUpdate(pm: TPackageManager, packageName: string): Promise<boolean> {
+    let command: string;
+
+    switch (pm) {
+      case 'npm':
+        command = `npm install -g ${packageName}@latest`;
+        break;
+      case 'yarn':
+        command = `yarn global add ${packageName}@latest`;
+        break;
+      case 'pnpm':
+        command = `pnpm add -g ${packageName}@latest`;
+        break;
+    }
+
+    console.log(`  Updating ${packageName} via ${pm}...`);
+
+    try {
+      const result = await this.shell.exec(command);
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Compare two semver versions
+   * Returns true if latest > current
+   */
+  public isNewerVersion(current: string, latest: string): boolean {
+    const cleanVersion = (v: string) => v.replace(/^[^\d]*/, '');
+    const currentClean = cleanVersion(current);
+    const latestClean = cleanVersion(latest);
+
+    const currentParts = currentClean.split('.').map(n => parseInt(n, 10) || 0);
+    const latestParts = latestClean.split('.').map(n => parseInt(n, 10) || 0);
+
+    for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+      const curr = currentParts[i] || 0;
+      const lat = latestParts[i] || 0;
+      if (lat > curr) return true;
+      if (lat < curr) return false;
+    }
+
+    return false;
+  }
+}

ts/mod_update/index.ts

@@ -0,0 +1,135 @@
+import * as plugins from './mod.plugins.js';
+import { PackageManagerUtil, type TPackageManager, type IPackageUpdateInfo } from './classes.packagemanager.js';
+
+const GITZONE_PACKAGES = [
+  '@git.zone/cli',
+  '@git.zone/tsdoc',
+  '@git.zone/tsbuild',
+  '@git.zone/tstest',
+  '@git.zone/tspublish',
+  '@git.zone/tsbundle',
+  '@git.zone/tsdocker',
+  '@git.zone/tsview',
+  '@git.zone/tswatch',
+];
+
+export interface IUpdateOptions {
+  yes?: boolean;
+}
+
+export const run = async (options: IUpdateOptions = {}): Promise<void> => {
+  const pmUtil = new PackageManagerUtil();
+
+  console.log('Scanning for installed @git.zone packages...\n');
+
+  // Check which package managers are available
+  const availablePMs: TPackageManager[] = [];
+  for (const pm of ['npm', 'yarn', 'pnpm'] as TPackageManager[]) {
+    if (await pmUtil.isAvailable(pm)) {
+      availablePMs.push(pm);
+    }
+  }
+
+  if (availablePMs.length === 0) {
+    console.log('No package managers found (npm, yarn, pnpm).');
+    return;
+  }
+
+  console.log(`Found package managers: ${availablePMs.join(', ')}\n`);
+
+  // Collect all installed @git.zone packages from all package managers
+  const allPackages: IPackageUpdateInfo[] = [];
+
+  for (const pm of availablePMs) {
+    const installed = await pmUtil.getInstalledPackages(pm);
+    for (const pkg of installed) {
+      // Only include packages from our predefined list
+      if (GITZONE_PACKAGES.includes(pkg.name)) {
+        const latestVersion = await pmUtil.getLatestVersion(pkg.name);
+        if (latestVersion) {
+          allPackages.push({
+            name: pkg.name,
+            currentVersion: pkg.version,
+            latestVersion,
+            packageManager: pm,
+            needsUpdate: pmUtil.isNewerVersion(pkg.version, latestVersion),
+          });
+        }
+      }
+    }
+  }
+
+  if (allPackages.length === 0) {
+    console.log('No @git.zone packages found installed globally.');
+    return;
+  }
+
+  // Display package table
+  console.log('Installed @git.zone packages:\n');
+  console.log('  Package                      Current     Latest      PM      Status');
+  console.log('  ─────────────────────────────────────────────────────────────────────');
+
+  for (const pkg of allPackages) {
+    const name = pkg.name.padEnd(28);
+    const current = pkg.currentVersion.padEnd(12);
+    const latest = pkg.latestVersion.padEnd(12);
+    const pm = pkg.packageManager.padEnd(8);
+    const status = pkg.needsUpdate ? '⬆️  Update available' : '✓ Up to date';
+    console.log(`  ${name}${current}${latest}${pm}${status}`);
+  }
+
+  console.log('');
+
+  // Filter packages that need updates
+  const packagesToUpdate = allPackages.filter(p => p.needsUpdate);
+
+  if (packagesToUpdate.length === 0) {
+    console.log('All packages are up to date!');
+    return;
+  }
+
+  console.log(`Found ${packagesToUpdate.length} package(s) with available updates.\n`);
+
+  // Ask for confirmation unless -y flag is provided
+  let shouldUpdate = options.yes === true;
+
+  if (!shouldUpdate) {
+    const smartinteractInstance = new plugins.smartinteract.SmartInteract();
+    const answer = await smartinteractInstance.askQuestion({
+      type: 'confirm',
+      name: 'confirmUpdate',
+      message: 'Do you want to update these packages?',
+      default: true,
+    });
+    shouldUpdate = answer.value === true;
+  }
+
+  if (!shouldUpdate) {
+    console.log('Update cancelled.');
+    return;
+  }
+
+  // Execute updates
+  console.log('\nUpdating packages...\n');
+
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const pkg of packagesToUpdate) {
+    const success = await pmUtil.executeUpdate(pkg.packageManager, pkg.name);
+    if (success) {
+      console.log(`  ✓ ${pkg.name} updated successfully`);
+      successCount++;
+    } else {
+      console.log(`  ✗ ${pkg.name} update failed`);
+      failCount++;
+    }
+  }
+
+  console.log('');
+  if (failCount === 0) {
+    console.log(`All ${successCount} package(s) updated successfully!`);
+  } else {
+    console.log(`Updated ${successCount} package(s), ${failCount} failed.`);
+  }
+};

ts/mod_update/mod.plugins.ts

@@ -0,0 +1,4 @@
+import * as smartinteract from '@push.rocks/smartinteract';
+import * as smartshell from '@push.rocks/smartshell';
+
+export { smartinteract, smartshell };

ts/tools.cli.ts

@@ -1,13 +1,23 @@
 import * as plugins from './tools.plugins.js';
+import * as modUpdate from './mod_update/index.js';
 
 export const run = async () => {
   const toolsCli = new plugins.smartcli.Smartcli();
 
   toolsCli.standardCommand().subscribe(async (argvArg) => {
-    console.log('@git.zone/tools - CLI placeholder');
-    console.log('No commands implemented yet.');
+    console.log('@git.zone/tools - CLI utility for managing @git.zone packages\n');
+    console.log('Commands:');
+    console.log('  update       Check and update globally installed @git.zone packages');
+    console.log('  update -y    Update without confirmation prompt');
+    console.log('');
+    console.log('Use "gtools <command> --help" for more information about a command.');
   });
 
-  toolsCli.addVersion('2.0.22');
+  toolsCli.addCommand('update').subscribe(async (argvArg) => {
+    const yesFlag = argvArg.y === true || argvArg.yes === true;
+    await modUpdate.run({ yes: yesFlag });
+  });
+
+  toolsCli.addVersion('3.0.0');
   toolsCli.startParse();
 };

ts/tools.plugins.ts

@@ -1,4 +1,6 @@
 // push.rocks scope
 import * as smartcli from '@push.rocks/smartcli';
+import * as smartinteract from '@push.rocks/smartinteract';
+import * as smartshell from '@push.rocks/smartshell';
 
-export { smartcli };
+export { smartcli, smartinteract, smartshell };