v3.5.0

changelog.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## 2026-02-09 - 3.5.0 - feat(install)
+add interactive install command and module to detect and install missing @git.zone packages
+
+- Add ts/mod_install/index.ts: implements interactive/non-interactive flow to detect package managers, collect installed @git.zone packages, prompt user (via smartinteract) and install selected packages via PackageManagerUtil.
+- Add ts/mod_install/mod.plugins.ts: re-export smartinteract and smartshell for the installer.
+- Update ts/tools.cli.ts: register new 'install' command and add help text for install flags.
+- Update ts/mod_update/index.ts: export GITZONE_PACKAGES and print a summary of managed packages that are not installed with latest versions and a suggestion to run 'gtools install'.
+
+## 2026-02-09 - 3.4.1 - fix(tools)
+no changes to commit
+
+- No files changed in this diff
+- Current package version is 3.4.0 — no version bump required
+
+## 2026-02-09 - 3.4.0 - feat(mod_update)
+add @git.zone/tsrust to supported modules list
+
+- ts/mod_update/index.ts: added '@git.zone/tsrust' to the modules array
+
+## 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
 

package.json

@@ -1,13 +1,13 @@
 {
   "name": "@git.zone/tools",
-  "version": "3.1.1",
+  "version": "3.5.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": {

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.1.1',
+  version: '3.5.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_install/index.ts

@@ -0,0 +1,151 @@
+import * as plugins from './mod.plugins.js';
+import { PackageManagerUtil, type TPackageManager, type IPackageManagerInfo, type IInstalledPackage } from '../mod_update/classes.packagemanager.js';
+import { GITZONE_PACKAGES } from '../mod_update/index.js';
+
+export interface IInstallOptions {
+  yes?: boolean;
+  verbose?: boolean;
+}
+
+export const run = async (options: IInstallOptions = {}): Promise<void> => {
+  const pmUtil = new PackageManagerUtil();
+  const verbose = options.verbose === true;
+
+  console.log('Scanning for missing @git.zone packages...\n');
+
+  // 1. Detect available 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 (detectedPMs.length === 0) {
+    console.log('No package managers found (npm, yarn, pnpm).');
+    return;
+  }
+
+  if (verbose) {
+    console.log(`Detected package managers: ${detectedPMs.map(p => p.name).join(', ')}\n`);
+  }
+
+  // 2. Collect all globally installed @git.zone packages across all PMs
+  const installedByPm = new Map<TPackageManager, IInstalledPackage[]>();
+  const allInstalledNames = new Set<string>();
+
+  for (const pmInfo of detectedPMs) {
+    const installed = await pmUtil.getInstalledPackages(pmInfo.name);
+    installedByPm.set(pmInfo.name, installed);
+    for (const pkg of installed) {
+      if (GITZONE_PACKAGES.includes(pkg.name)) {
+        allInstalledNames.add(pkg.name);
+      }
+    }
+  }
+
+  // 3. Determine which managed packages are not installed
+  const notInstalled = GITZONE_PACKAGES.filter(name => !allInstalledNames.has(name));
+
+  if (notInstalled.length === 0) {
+    console.log('All managed @git.zone packages are already installed.');
+    return;
+  }
+
+  console.log(`Found ${notInstalled.length} package(s) not installed.\n`);
+
+  // 4. Determine the best default PM (the one with most @git.zone packages)
+  let bestPm = detectedPMs[0].name;
+  let bestCount = 0;
+  for (const pmInfo of detectedPMs) {
+    const pkgs = installedByPm.get(pmInfo.name) || [];
+    const gitzoneCount = pkgs.filter(p => GITZONE_PACKAGES.includes(p.name)).length;
+    if (gitzoneCount > bestCount) {
+      bestCount = gitzoneCount;
+      bestPm = pmInfo.name;
+    }
+  }
+
+  let selectedPm: TPackageManager;
+  let selectedPackages: string[];
+
+  if (options.yes === true) {
+    // Non-interactive: use best PM, install all missing
+    selectedPm = bestPm;
+    selectedPackages = notInstalled;
+    console.log(`Using ${selectedPm} (auto-detected).\n`);
+  } else {
+    // 5. Ask which PM to use
+    const smartinteractInstance = new plugins.smartinteract.SmartInteract();
+
+    if (detectedPMs.length === 1) {
+      selectedPm = detectedPMs[0].name;
+      console.log(`Using ${selectedPm} (only available PM).\n`);
+    } else {
+      const pmAnswer = await smartinteractInstance.askQuestion({
+        name: 'packageManager',
+        type: 'list',
+        message: 'Which package manager should be used for installation?',
+        default: bestPm,
+        choices: detectedPMs.map(pm => ({
+          name: `${pm.name}${pm.name === bestPm ? ' (recommended — most @git.zone packages)' : ''}`,
+          value: pm.name,
+        })),
+      });
+      selectedPm = pmAnswer.value as TPackageManager;
+    }
+
+    // 6. Ask which packages to install
+    // Fetch latest versions for display
+    const choicesWithVersions: Array<{ name: string; value: string }> = [];
+    for (const pkgName of notInstalled) {
+      const latest = await pmUtil.getLatestVersion(pkgName);
+      const versionLabel = latest ? `@${latest}` : '';
+      choicesWithVersions.push({
+        name: `${pkgName}${versionLabel}`,
+        value: pkgName,
+      });
+    }
+
+    const pkgAnswer = await smartinteractInstance.askQuestion({
+      name: 'packages',
+      type: 'checkbox',
+      message: 'Select packages to install:',
+      default: notInstalled, // all pre-checked
+      choices: choicesWithVersions,
+    });
+
+    selectedPackages = pkgAnswer.value as string[];
+
+    if (selectedPackages.length === 0) {
+      console.log('No packages selected. Nothing to install.');
+      return;
+    }
+  }
+
+  // 7. Install selected packages
+  console.log(`Installing ${selectedPackages.length} package(s) via ${selectedPm}...\n`);
+
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const pkgName of selectedPackages) {
+    const success = await pmUtil.executeUpdate(selectedPm, pkgName);
+    if (success) {
+      console.log(`  ✓ ${pkgName} installed successfully`);
+      successCount++;
+    } else {
+      console.log(`  ✗ ${pkgName} installation failed`);
+      failCount++;
+    }
+  }
+
+  // 8. Summary
+  console.log('');
+  if (failCount === 0) {
+    console.log(`All ${successCount} package(s) installed successfully!`);
+  } else {
+    console.log(`Installed ${successCount} package(s), ${failCount} failed.`);
+  }
+};

ts/mod_install/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/mod_update/classes.packagemanager.ts

@@ -16,6 +16,16 @@ export interface IPackageUpdateInfo {
   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',
@@ -23,14 +33,92 @@ export class PackageManagerUtil {
 
   /**
    * 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): Promise<boolean> {
+  public async isAvailable(pm: TPackageManager, verbose = false): Promise<boolean> {
-    try {
+    const info = await this.detectPackageManager(pm, verbose);
-      const result = await this.shell.execSilent(`which ${pm} >/dev/null 2>&1 && echo "found"`);
+    return info.available;
-      return result.exitCode === 0 && result.stdout.includes('found');
-    } catch {
-      return false;
   }
+
+  /**
+   * 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 };
   }
 
   /**
@@ -103,12 +191,11 @@ export class PackageManagerUtil {
             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] || '';
+                const parsed = PackageManagerUtil.parseYarnPackageName(tree.name || '');
-                if (name.startsWith('@git.zone/')) {
+                if (parsed.name.startsWith('@git.zone/')) {
-                  const version = tree.name?.split('@').pop() || 'unknown';
                   packages.push({
-                    name,
+                    name: parsed.name,
-                    version,
+                    version: parsed.version,
                     packageManager: pm,
                   });
                 }
@@ -128,8 +215,28 @@ export class PackageManagerUtil {
 
   /**
    * 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()) {
@@ -169,6 +276,26 @@ export class PackageManagerUtil {
     }
   }
 
+  /**
+   * 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

ts/mod_update/index.ts

@@ -1,7 +1,11 @@
 import * as plugins from './mod.plugins.js';
-import { PackageManagerUtil, type TPackageManager, type IPackageUpdateInfo } from './classes.packagemanager.js';
+import { PackageManagerUtil, type TPackageManager, type IPackageUpdateInfo, type IPackageManagerInfo } from './classes.packagemanager.js';
+import { commitinfo } from '../00_commitinfo_data.js';
 
-const GITZONE_PACKAGES = [
+// 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.
+export const GITZONE_PACKAGES = [
   '@git.zone/cli',
   '@git.zone/tsdoc',
   '@git.zone/tsbuild',
@@ -11,53 +15,136 @@ const GITZONE_PACKAGES = [
   '@git.zone/tsdocker',
   '@git.zone/tsview',
   '@git.zone/tswatch',
+  '@git.zone/tsrust',
 ];
 
 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
-  const availablePMs: TPackageManager[] = [];
+  if (verbose) {
+    console.log('Detecting package managers:');
+  }
+
+  const detectedPMs: IPackageManagerInfo[] = [];
   for (const pm of ['npm', 'yarn', 'pnpm'] as TPackageManager[]) {
-    if (await pmUtil.isAvailable(pm)) {
+    const info = await pmUtil.detectPackageManager(pm, verbose);
-      availablePMs.push(pm);
+    if (info.available) {
+      detectedPMs.push(info);
     }
   }
 
-  if (availablePMs.length === 0) {
+  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;
   }
 
-  console.log(`Found package managers: ${availablePMs.join(', ')}\n`);
+  // 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 pm of availablePMs) {
+  for (const pmInfo of detectedPMs) {
-    const installed = await pmUtil.getInstalledPackages(pm);
+    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);
-        if (latestVersion) {
         allPackages.push({
           name: pkg.name,
           currentVersion: pkg.version,
-            latestVersion,
+          latestVersion: latestVersion || 'unknown',
-            packageManager: pm,
+          packageManager: pmInfo.name,
-            needsUpdate: pmUtil.isNewerVersion(pkg.version, latestVersion),
+          needsUpdate: latestVersion ? pmUtil.isNewerVersion(pkg.version, latestVersion) : false,
         });
       }
     }
   }
-  }
 
   if (allPackages.length === 0) {
     console.log('No @git.zone packages found installed globally.');
@@ -74,12 +161,34 @@ export const run = async (options: IUpdateOptions = {}): Promise<void> => {
     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';
+    const status = pkg.latestVersion === 'unknown'
+      ? '? Version unknown'
+      : pkg.needsUpdate
+        ? '⬆️  Update available'
+        : '✓ Up to date';
     console.log(`  ${name}${current}${latest}${pm}${status}`);
   }
 
   console.log('');
 
+  // Show managed packages that are not installed anywhere
+  const installedNames = new Set(allPackages.map(p => p.name));
+  const notInstalled = GITZONE_PACKAGES.filter(name => !installedNames.has(name));
+
+  if (notInstalled.length > 0) {
+    console.log('Not installed (managed @git.zone packages):\n');
+    console.log('  Package                      Latest');
+    console.log('  ─────────────────────────────────────────');
+    for (const pkgName of notInstalled) {
+      const latest = await pmUtil.getLatestVersion(pkgName);
+      const name = pkgName.padEnd(28);
+      const version = latest || 'unknown';
+      console.log(`  ${name}  ${version}`);
+    }
+    console.log('');
+    console.log('  Run "gtools install" to install missing packages.\n');
+  }
+
   // Filter packages that need updates
   const packagesToUpdate = allPackages.filter(p => p.needsUpdate);
 

ts/tools.cli.ts

@@ -1,5 +1,7 @@
 import * as plugins from './tools.plugins.js';
 import * as modUpdate from './mod_update/index.js';
+import * as modInstall from './mod_install/index.js';
+import { commitinfo } from './00_commitinfo_data.js';
 
 export const run = async () => {
   const toolsCli = new plugins.smartcli.Smartcli();
@@ -9,15 +11,26 @@ export const run = async () => {
     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('  install            Interactively install missing @git.zone packages');
+    console.log('  install -y         Install all missing packages without prompts');
+    console.log('  install --verbose  Show detection diagnostics');
     console.log('');
     console.log('Use "gtools <command> --help" for more information about a command.');
   });
 
   toolsCli.addCommand('update').subscribe(async (argvArg) => {
     const yesFlag = argvArg.y === true || argvArg.yes === true;
-    await modUpdate.run({ yes: yesFlag });
+    const verboseFlag = argvArg.v === true || argvArg.verbose === true;
+    await modUpdate.run({ yes: yesFlag, verbose: verboseFlag });
   });
 
-  toolsCli.addVersion('3.0.0');
+  toolsCli.addCommand('install').subscribe(async (argvArg) => {
+    const yesFlag = argvArg.y === true || argvArg.yes === true;
+    const verboseFlag = argvArg.v === true || argvArg.verbose === true;
+    await modInstall.run({ yes: yesFlag, verbose: verboseFlag });
+  });
+
+  toolsCli.addVersion(commitinfo.version);
   toolsCli.startParse();
 };