v3.5.0

changelog.md

@@ -1,5 +1,33 @@
 # 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
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tools",
-  "version": "3.2.0",
+  "version": "3.5.0",
   "private": false,
   "type": "module",
   "description": "A CLI tool placeholder for development utilities.",

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.2.0',
+  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

@@ -191,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] || '';
-                if (name.startsWith('@git.zone/')) {
-                  const version = tree.name?.split('@').pop() || 'unknown';
+                const parsed = PackageManagerUtil.parseYarnPackageName(tree.name || '');
+                if (parsed.name.startsWith('@git.zone/')) {
                   packages.push({
-                    name,
-                    version,
+                    name: parsed.name,
+                    version: parsed.version,
                     packageManager: pm,
                   });
                 }
@@ -277,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, 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,6 +15,7 @@ const GITZONE_PACKAGES = [
   '@git.zone/tsdocker',
   '@git.zone/tsview',
   '@git.zone/tswatch',
+  '@git.zone/tsrust',
 ];
 
 export interface IUpdateOptions {
@@ -73,6 +78,54 @@ export const run = async (options: IUpdateOptions = {}): Promise<void> => {
 
   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[] = [];
 
@@ -118,6 +171,24 @@ export const run = async (options: IUpdateOptions = {}): Promise<void> => {
 
   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();
@@ -7,9 +9,12 @@ export const run = async () => {
   toolsCli.standardCommand().subscribe(async (argvArg) => {
     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('  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.');
   });
@@ -20,6 +25,12 @@ export const run = async () => {
     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();
 };