v3.3.0

.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,55 @@
 # Changelog
 
+## 2026-02-06 - 3.3.0 - feat(mod_update)
+add self-update flow, package name parser, dynamic CLI version, and tests
+
+- Add a self-update check in mod_update to detect and optionally update @git.zone/tools (prompts the user or uses --yes).
+- Introduce PackageManagerUtil.parseYarnPackageName to correctly parse scoped and unscoped yarn package strings and use it when collecting installed packages.
+- Add comprehensive unit tests for PackageManagerUtil.isNewerVersion and parseYarnPackageName.
+- Use commitinfo.version for CLI reported version instead of a hardcoded value.
+- Remove automatic invocation of runCli() from ts/index.ts to avoid immediate execution on import.
+
+## 2026-02-05 - 3.2.0 - feat(update)
+enhance package manager detection, version reporting, and add verbose option
+
+- Add IPackageManagerInfo interface and detectPackageManager() to robustly detect npm/yarn/pnpm via 'which' and '--version' fallbacks
+- Make isAvailable() delegate to detectPackageManager() and return structured detection info
+- Add getPackageManagerVersion() to obtain current and latest versions (parses local --version and queries npm registry)
+- Update run() to support a verbose flag, show a package-manager status table, and collect detectedPMs with version/update status
+- Update CLI help and command handling to accept --verbose/-v and pass it through to mod_update.run()
+
+## 2026-02-03 - 3.1.3 - fix(mod_update)
+try private registry (verdaccio.lossless.digital) first when fetching package versions; fall back to public npm; handle unknown latest versions gracefully in output
+
+- getLatestVersion now attempts a direct API request to https://verdaccio.lossless.digital/<encoded-package> and parses dist-tags.latest
+- Falls back to npm view when the private registry request fails
+- Scoped package names are URL-encoded (replaces '/' with '%2f') before querying the private registry
+- Packages with no resolvable latest version are included with latestVersion set to 'unknown' and displayed as '? Version unknown'
+- needsUpdate is set to false when latest version is unknown
+
+## 2026-02-03 - 3.1.2 - fix(scripts)
+make test script output verbose by using --verbose instead of --web
+
+- package.json: change npm "test" script from "(tstest test/ --web)" to "(tstest test/ --verbose)" to enable verbose test output
+
+## 2026-02-03 - 3.1.1 - fix(tools)
+no changes detected
+
+- No files were modified in this diff
+- No code or documentation changes to include in a commit message
+
+## 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

@@ -1,13 +1,13 @@
 {
   "name": "@git.zone/tools",
-  "version": "3.0.0",
+  "version": "3.3.0",
   "private": false,
   "type": "module",
   "description": "A CLI tool placeholder for development utilities.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "scripts": {
-    "test": "(tstest test/ --web)",
+    "test": "(tstest test/ --verbose)",
     "build": "(tsbuild --web)"
   },
   "bin": {
@@ -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

test/test.node.ts

@@ -1,9 +1,93 @@
 import { expect, tap } from '@git.zone/tstest/tapbundle';
 
 import * as tools from '../ts/index.js';
+import { PackageManagerUtil } from '../ts/mod_update/classes.packagemanager.js';
 
 tap.test('should export runCli function', async () => {
   expect(typeof tools.runCli).toEqual('function');
 });
 
+// ============================================
+// isNewerVersion tests
+// ============================================
+
+tap.test('isNewerVersion: should detect newer major version', async () => {
+  const pmUtil = new PackageManagerUtil();
+  expect(pmUtil.isNewerVersion('1.0.0', '2.0.0')).toBeTrue();
+});
+
+tap.test('isNewerVersion: should detect newer minor version', async () => {
+  const pmUtil = new PackageManagerUtil();
+  expect(pmUtil.isNewerVersion('1.0.0', '1.1.0')).toBeTrue();
+});
+
+tap.test('isNewerVersion: should detect newer patch version', async () => {
+  const pmUtil = new PackageManagerUtil();
+  expect(pmUtil.isNewerVersion('1.0.0', '1.0.1')).toBeTrue();
+});
+
+tap.test('isNewerVersion: should return false for equal versions', async () => {
+  const pmUtil = new PackageManagerUtil();
+  expect(pmUtil.isNewerVersion('1.0.0', '1.0.0')).toBeFalse();
+});
+
+tap.test('isNewerVersion: should return false when current is newer', async () => {
+  const pmUtil = new PackageManagerUtil();
+  expect(pmUtil.isNewerVersion('2.0.0', '1.0.0')).toBeFalse();
+  expect(pmUtil.isNewerVersion('1.1.0', '1.0.0')).toBeFalse();
+  expect(pmUtil.isNewerVersion('1.0.1', '1.0.0')).toBeFalse();
+});
+
+tap.test('isNewerVersion: should handle v-prefixed versions', async () => {
+  const pmUtil = new PackageManagerUtil();
+  expect(pmUtil.isNewerVersion('v1.0.0', 'v2.0.0')).toBeTrue();
+  expect(pmUtil.isNewerVersion('v2.0.0', 'v1.0.0')).toBeFalse();
+});
+
+tap.test('isNewerVersion: should handle mixed prefixed and non-prefixed', async () => {
+  const pmUtil = new PackageManagerUtil();
+  expect(pmUtil.isNewerVersion('v1.0.0', '2.0.0')).toBeTrue();
+  expect(pmUtil.isNewerVersion('1.0.0', 'v2.0.0')).toBeTrue();
+});
+
+tap.test('isNewerVersion: should handle versions with different segment counts', async () => {
+  const pmUtil = new PackageManagerUtil();
+  expect(pmUtil.isNewerVersion('1.0', '1.0.1')).toBeTrue();
+  expect(pmUtil.isNewerVersion('1.0.1', '1.0')).toBeFalse();
+});
+
+// ============================================
+// parseYarnPackageName tests
+// ============================================
+
+tap.test('parseYarnPackageName: should parse scoped package correctly', async () => {
+  const result = PackageManagerUtil.parseYarnPackageName('@git.zone/cli@1.2.3');
+  expect(result.name).toEqual('@git.zone/cli');
+  expect(result.version).toEqual('1.2.3');
+});
+
+tap.test('parseYarnPackageName: should parse unscoped package correctly', async () => {
+  const result = PackageManagerUtil.parseYarnPackageName('typescript@5.3.2');
+  expect(result.name).toEqual('typescript');
+  expect(result.version).toEqual('5.3.2');
+});
+
+tap.test('parseYarnPackageName: should handle empty string', async () => {
+  const result = PackageManagerUtil.parseYarnPackageName('');
+  expect(result.name).toEqual('');
+  expect(result.version).toEqual('unknown');
+});
+
+tap.test('parseYarnPackageName: should handle name with no version', async () => {
+  const result = PackageManagerUtil.parseYarnPackageName('@git.zone/cli');
+  expect(result.name).toEqual('@git.zone/cli');
+  expect(result.version).toEqual('unknown');
+});
+
+tap.test('parseYarnPackageName: should handle unscoped name with no version', async () => {
+  const result = PackageManagerUtil.parseYarnPackageName('typescript');
+  expect(result.name).toEqual('typescript');
+  expect(result.version).toEqual('unknown');
+});
+
 export default tap.start();

ts/00_commitinfo_data.ts

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

ts/index.ts

@@ -3,5 +3,3 @@ import * as cli from './tools.cli.js';
 export const runCli = async () => {
   await cli.run();
 };
-
-runCli();

ts/mod_update/classes.packagemanager.ts

@@ -0,0 +1,320 @@
+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 interface IPackageManagerInfo {
+  name: TPackageManager;
+  available: boolean;
+  detectionMethod?: 'which' | 'version-command';
+  path?: string;
+  currentVersion?: string;
+  latestVersion?: string | null;
+  needsUpdate?: boolean;
+}
+
+export class PackageManagerUtil {
+  private shell = new plugins.smartshell.Smartshell({
+    executor: 'bash',
+  });
+
+  /**
+   * Check if a package manager is available on the system
+   * Uses multiple detection methods for robustness across different shell contexts
+   */
+  public async isAvailable(pm: TPackageManager, verbose = false): Promise<boolean> {
+    const info = await this.detectPackageManager(pm, verbose);
+    return info.available;
+  }
+
+  /**
+   * Detect a package manager and return detailed info
+   */
+  public async detectPackageManager(pm: TPackageManager, verbose = false): Promise<IPackageManagerInfo> {
+    const info: IPackageManagerInfo = { name: pm, available: false };
+
+    // Primary method: try 'which' command
+    try {
+      const whichResult = await this.shell.execSilent(`which ${pm} 2>/dev/null`);
+      if (whichResult.exitCode === 0 && whichResult.stdout.trim()) {
+        info.available = true;
+        info.detectionMethod = 'which';
+        info.path = whichResult.stdout.trim();
+        if (verbose) {
+          console.log(`  Checking ${pm}... found via 'which' at ${info.path}`);
+        }
+        return info;
+      }
+    } catch {
+      // Continue to fallback
+    }
+
+    // Fallback method: try running pm --version directly
+    // This can find PMs that are available but not in PATH for 'which'
+    try {
+      const versionResult = await this.shell.execSilent(`${pm} --version 2>/dev/null`);
+      if (versionResult.exitCode === 0 && versionResult.stdout.trim()) {
+        info.available = true;
+        info.detectionMethod = 'version-command';
+        if (verbose) {
+          console.log(`  Checking ${pm}... found via '--version' (which failed)`);
+        }
+        return info;
+      }
+    } catch {
+      // Not available
+    }
+
+    if (verbose) {
+      console.log(`  Checking ${pm}... not found`);
+    }
+    return info;
+  }
+
+  /**
+   * Get the current and latest version of a package manager
+   */
+  public async getPackageManagerVersion(pm: TPackageManager): Promise<{ current: string; latest: string | null }> {
+    let current = 'unknown';
+    let latest: string | null = null;
+
+    // Get current version
+    try {
+      const result = await this.shell.execSilent(`${pm} --version 2>/dev/null`);
+      if (result.exitCode === 0 && result.stdout.trim()) {
+        // Parse version from output - handle different formats
+        const output = result.stdout.trim();
+        // npm: "10.2.0", pnpm: "8.15.0", yarn: "1.22.19"
+        // Some may include prefix like "v1.22.19"
+        const versionMatch = output.match(/(\d+\.\d+\.\d+)/);
+        if (versionMatch) {
+          current = versionMatch[1];
+        }
+      }
+    } catch {
+      // Keep as unknown
+    }
+
+    // Get latest version from npm registry
+    try {
+      const result = await this.shell.execSilent(`npm view ${pm} version 2>/dev/null`);
+      if (result.exitCode === 0 && result.stdout.trim()) {
+        latest = result.stdout.trim();
+      }
+    } catch {
+      // Keep as null
+    }
+
+    return { current, latest };
+  }
+
+  /**
+   * 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 parsed = PackageManagerUtil.parseYarnPackageName(tree.name || '');
+                if (parsed.name.startsWith('@git.zone/')) {
+                  packages.push({
+                    name: parsed.name,
+                    version: parsed.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
+   * Tries private registry (verdaccio.lossless.digital) first via API, then falls back to public npm
+   */
+  public async getLatestVersion(packageName: string): Promise<string | null> {
+    // URL-encode the package name for scoped packages (@scope/name -> @scope%2fname)
+    const encodedName = packageName.replace('/', '%2f');
+
+    // Try private registry first via direct API call (npm view doesn't work reliably)
+    try {
+      const result = await this.shell.execSilent(
+        `curl -sf "https://verdaccio.lossless.digital/${encodedName}" 2>/dev/null`
+      );
+      if (result.exitCode === 0 && result.stdout.trim()) {
+        const data = JSON.parse(result.stdout.trim());
+        if (data['dist-tags']?.latest) {
+          return data['dist-tags'].latest;
+        }
+      }
+    } catch {
+      // Continue to public registry
+    }
+
+    // Fall back to public npm
+    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;
+    }
+  }
+
+  /**
+   * Parse a yarn package name string like "@git.zone/cli@1.0.0" into name and version.
+   * Handles scoped packages correctly by splitting on the last '@' (version separator).
+   */
+  public static parseYarnPackageName(fullName: string): { name: string; version: string } {
+    if (!fullName) {
+      return { name: '', version: 'unknown' };
+    }
+    const lastAtIndex = fullName.lastIndexOf('@');
+    // If lastAtIndex is 0, the string is just "@something" with no version
+    // If lastAtIndex is -1, there's no '@' at all
+    if (lastAtIndex <= 0) {
+      return { name: fullName, version: 'unknown' };
+    }
+    return {
+      name: fullName.substring(0, lastAtIndex),
+      version: fullName.substring(lastAtIndex + 1) || 'unknown',
+    };
+  }
+
+  /**
+   * 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,225 @@
+import * as plugins from './mod.plugins.js';
+import { PackageManagerUtil, type TPackageManager, type IPackageUpdateInfo, type IPackageManagerInfo } from './classes.packagemanager.js';
+import { commitinfo } from '../00_commitinfo_data.js';
+
+// Curated list of known @git.zone CLI tools to track for updates.
+// This list is intentionally hardcoded to only track official tools.
+// Add new entries here when new @git.zone packages are published.
+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;
+  verbose?: boolean;
+}
+
+export const run = async (options: IUpdateOptions = {}): Promise<void> => {
+  const pmUtil = new PackageManagerUtil();
+  const verbose = options.verbose === true;
+
+  console.log('Scanning for installed @git.zone packages...\n');
+
+  // Check which package managers are available
+  if (verbose) {
+    console.log('Detecting package managers:');
+  }
+
+  const detectedPMs: IPackageManagerInfo[] = [];
+  for (const pm of ['npm', 'yarn', 'pnpm'] as TPackageManager[]) {
+    const info = await pmUtil.detectPackageManager(pm, verbose);
+    if (info.available) {
+      detectedPMs.push(info);
+    }
+  }
+
+  if (verbose) {
+    console.log('');
+  }
+
+  if (detectedPMs.length === 0) {
+    console.log('No package managers found (npm, yarn, pnpm).');
+    console.log('Tried detection via \'which\' command and direct version check.');
+    return;
+  }
+
+  // Get version info for each PM and display status table
+  console.log('Package managers:\n');
+  console.log('  Name     Current     Latest      Status');
+  console.log('  ──────────────────────────────────────────────');
+
+  for (const pmInfo of detectedPMs) {
+    const versionInfo = await pmUtil.getPackageManagerVersion(pmInfo.name);
+    pmInfo.currentVersion = versionInfo.current;
+    pmInfo.latestVersion = versionInfo.latest;
+    pmInfo.needsUpdate = versionInfo.latest
+      ? pmUtil.isNewerVersion(versionInfo.current, versionInfo.latest)
+      : false;
+
+    const name = pmInfo.name.padEnd(9);
+    const current = versionInfo.current.padEnd(12);
+    const latest = (versionInfo.latest || 'unknown').padEnd(12);
+    const status = versionInfo.latest === null
+      ? '? Version unknown'
+      : pmInfo.needsUpdate
+        ? '⬆️  Update available'
+        : '✓ Up to date';
+    console.log(`  ${name}${current}${latest}${status}`);
+  }
+
+  console.log('');
+
+  // === Self-update check ===
+  console.log('Checking for gtools self-update...\n');
+  const selfVersion = commitinfo.version;
+  const selfLatest = await pmUtil.getLatestVersion('@git.zone/tools');
+
+  if (selfLatest && pmUtil.isNewerVersion(selfVersion, selfLatest)) {
+    console.log(`  @git.zone/tools  ${selfVersion} → ${selfLatest}  ⬆️  Update available\n`);
+
+    // Find which PM has it installed globally
+    let selfPm: TPackageManager | null = null;
+    for (const pmInfo of detectedPMs) {
+      const installed = await pmUtil.getInstalledPackages(pmInfo.name);
+      if (installed.some(p => p.name === '@git.zone/tools')) {
+        selfPm = pmInfo.name;
+        break;
+      }
+    }
+
+    if (!selfPm) {
+      // Fallback: use first available PM
+      selfPm = detectedPMs[0].name;
+    }
+
+    let shouldSelfUpdate = options.yes === true;
+    if (!shouldSelfUpdate) {
+      const smartinteractInstance = new plugins.smartinteract.SmartInteract();
+      const answer = await smartinteractInstance.askQuestion({
+        type: 'confirm',
+        name: 'confirmSelfUpdate',
+        message: 'Do you want to update gtools itself first?',
+        default: true,
+      });
+      shouldSelfUpdate = answer.value === true;
+    }
+
+    if (shouldSelfUpdate) {
+      const success = await pmUtil.executeUpdate(selfPm, '@git.zone/tools');
+      if (success) {
+        console.log('\ngtools has been updated. Please re-run "gtools update" to check remaining packages.');
+        process.exit(0);
+      } else {
+        console.log('\ngtools self-update failed. Continuing with current version...\n');
+      }
+    }
+  } else {
+    console.log(`  @git.zone/tools  ${selfVersion}  ✓ Up to date\n`);
+  }
+
+  // Collect all installed @git.zone packages from all package managers
+  const allPackages: IPackageUpdateInfo[] = [];
+
+  for (const pmInfo of detectedPMs) {
+    const installed = await pmUtil.getInstalledPackages(pmInfo.name);
+    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);
+        allPackages.push({
+          name: pkg.name,
+          currentVersion: pkg.version,
+          latestVersion: latestVersion || 'unknown',
+          packageManager: pmInfo.name,
+          needsUpdate: latestVersion ? pmUtil.isNewerVersion(pkg.version, latestVersion) : false,
+        });
+      }
+    }
+  }
+
+  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.latestVersion === 'unknown'
+      ? '? Version unknown'
+      : 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,26 @@
 import * as plugins from './tools.plugins.js';
+import * as modUpdate from './mod_update/index.js';
+import { commitinfo } from './00_commitinfo_data.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('  update --verbose  Show detection diagnostics');
+    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;
+    const verboseFlag = argvArg.v === true || argvArg.verbose === true;
+    await modUpdate.run({ yes: yesFlag, verbose: verboseFlag });
+  });
+
+  toolsCli.addVersion(commitinfo.version);
   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 };