@git.zone/tswatch 2.3.12 → 3.0.0

package/ts/tswatch.classes.watcher.ts

@@ -1,11 +1,24 @@
 import * as plugins from './tswatch.plugins.js';
+import * as interfaces from './interfaces/index.js';
 import { logger } from './tswatch.logging.js';
 
 export interface IWatcherConstructorOptions {
-  filePathToWatch: string;
+  /** Name for this watcher (used in logging) */
+  name?: string;
+  /** Path(s) to watch - can be a single path or array */
+  filePathToWatch: string | string[];
+  /** Shell command to execute on changes */
   commandToExecute?: string;
+  /** Function to call on changes */
   functionToCall?: () => Promise<any>;
+  /** Timeout for the watcher */
   timeout?: number;
+  /** If true, kill previous process before restarting (default: true) */
+  restart?: boolean;
+  /** Debounce delay in ms (default: 300) */
+  debounce?: number;
+  /** If true, run the command immediately on start (default: true) */
+  runOnStart?: boolean;
 }
 
 /**
@@ -22,53 +35,148 @@ export class Watcher {
   private currentExecution: plugins.smartshell.IExecResultStreaming;
   private smartwatchInstance = new plugins.smartwatch.Smartwatch([]);
   private options: IWatcherConstructorOptions;
+  private debounceTimer: NodeJS.Timeout | null = null;
+  private isExecuting = false;
+  private pendingExecution = false;
 
   constructor(optionsArg: IWatcherConstructorOptions) {
-    this.options = optionsArg;
+    this.options = {
+      restart: true,
+      debounce: 300,
+      runOnStart: true,
+      ...optionsArg,
+    };
+  }
+
+  /**
+   * Create a Watcher from config
+   */
+  public static fromConfig(config: interfaces.IWatcherConfig): Watcher {
+    const watchPaths = Array.isArray(config.watch) ? config.watch : [config.watch];
+    return new Watcher({
+      name: config.name,
+      filePathToWatch: watchPaths,
+      commandToExecute: config.command,
+      restart: config.restart ?? true,
+      debounce: config.debounce ?? 300,
+      runOnStart: config.runOnStart ?? true,
+    });
+  }
+
+  /**
+   * Get the watcher name for logging
+   */
+  private getName(): string {
+    return this.options.name || 'unnamed';
   }
 
   /**
    * start the file
    */
   public async start() {
-    logger.log('info', `trying to start watcher for ${this.options.filePathToWatch}`);
+    const name = this.getName();
+    logger.log('info', `[${name}] starting watcher`);
     await this.setupCleanup();
-    console.log(`Looking at ${this.options.filePathToWatch} for changes`);
-    // Convert directory path to glob pattern for smartwatch
-    const watchPath = this.options.filePathToWatch.endsWith('/')
-      ? `${this.options.filePathToWatch}**/*`
-      : `${this.options.filePathToWatch}/**/*`;
-    this.smartwatchInstance.add([watchPath]);
+
+    // Convert paths to glob patterns
+    const paths = Array.isArray(this.options.filePathToWatch)
+      ? this.options.filePathToWatch
+      : [this.options.filePathToWatch];
+
+    const watchPatterns = paths.map((p) => {
+      // Convert directory path to glob pattern for smartwatch
+      if (p.endsWith('/')) {
+        return `${p}**/*`;
+      }
+      // If it's already a glob pattern, use as-is
+      if (p.includes('*')) {
+        return p;
+      }
+      // Otherwise assume it's a directory
+      return `${p}/**/*`;
+    });
+
+    logger.log('info', `[${name}] watching patterns: ${watchPatterns.join(', ')}`);
+    this.smartwatchInstance.add(watchPatterns);
     await this.smartwatchInstance.start();
+
     const changeObservable = await this.smartwatchInstance.getObservableFor('change');
     changeObservable.subscribe(() => {
-      this.updateCurrentExecution();
+      this.handleChange();
     });
-    await this.updateCurrentExecution();
-    logger.log('info', `watcher started for ${this.options.filePathToWatch}`);
+
+    // Run on start if configured
+    if (this.options.runOnStart) {
+      await this.executeCommand();
+    }
+
+    logger.log('info', `[${name}] watcher started`);
   }
 
   /**
-   * updates the current execution
+   * Handle file change with debouncing
    */
-  private async updateCurrentExecution() {
+  private handleChange() {
+    const name = this.getName();
+
+    // Clear existing debounce timer
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    // Set new debounce timer
+    this.debounceTimer = setTimeout(async () => {
+      this.debounceTimer = null;
+
+      // If currently executing and not in restart mode, mark pending
+      if (this.isExecuting && !this.options.restart) {
+        logger.log('info', `[${name}] change detected, queuing execution`);
+        this.pendingExecution = true;
+        return;
+      }
+
+      await this.executeCommand();
+
+      // If there was a pending execution, run it
+      if (this.pendingExecution) {
+        this.pendingExecution = false;
+        await this.executeCommand();
+      }
+    }, this.options.debounce);
+  }
+
+  /**
+   * Execute the command or function
+   */
+  private async executeCommand() {
+    const name = this.getName();
+
     if (this.options.commandToExecute) {
-      if (this.currentExecution) {
-        logger.log('ok', `reexecuting ${this.options.commandToExecute}`);
+      if (this.currentExecution && this.options.restart) {
+        logger.log('ok', `[${name}] restarting: ${this.options.commandToExecute}`);
         this.currentExecution.kill();
-      } else {
-        logger.log('ok', `executing ${this.options.commandToExecute} for the first time`);
+      } else if (!this.currentExecution) {
+        logger.log('ok', `[${name}] executing: ${this.options.commandToExecute}`);
       }
+
+      this.isExecuting = true;
       this.currentExecution = await this.smartshellInstance.execStreaming(
         this.options.commandToExecute,
       );
-    } else {
-      console.log('no executionCommand set');
+
+      // Track when execution completes
+      this.currentExecution.childProcess.on('exit', () => {
+        this.isExecuting = false;
+      });
     }
+
     if (this.options.functionToCall) {
-      this.options.functionToCall();
-    } else {
-      console.log('no functionToCall set.');
+      this.isExecuting = true;
+      try {
+        await this.options.functionToCall();
+      } finally {
+        this.isExecuting = false;
+      }
     }
   }
 
@@ -103,6 +211,9 @@ export class Watcher {
    * stops the watcher
    */
   public async stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
     await this.smartwatchInstance.stop();
     if (this.currentExecution && !this.currentExecution.childProcess.killed) {
       this.currentExecution.kill();

package/ts/tswatch.cli.ts

@@ -3,42 +3,48 @@ import * as paths from './tswatch.paths.js';
 import { logger } from './tswatch.logging.js';
 
 import { TsWatch } from './tswatch.classes.tswatch.js';
+import { ConfigHandler } from './tswatch.classes.confighandler.js';
+import { runInit } from './tswatch.init.js';
 
 const tswatchCli = new plugins.smartcli.Smartcli();
 
-// standard behaviour will assume gitzone setup
-tswatchCli.standardCommand().subscribe((argvArg) => {
-  tswatchCli.triggerCommand('npm', {});
+/**
+ * Standard command (no args) - run with config or launch wizard
+ */
+tswatchCli.standardCommand().subscribe(async (argvArg) => {
+  const configHandler = new ConfigHandler();
+
+  if (configHandler.hasConfig()) {
+    // Config exists - run with it
+    const tsWatch = TsWatch.fromConfig();
+    if (tsWatch) {
+      logger.log('info', 'Starting tswatch with configuration from npmextra.json');
+      await tsWatch.start();
+    } else {
+      logger.log('error', 'Failed to load configuration');
+      process.exit(1);
+    }
+  } else {
+    // No config - launch wizard
+    logger.log('info', 'No tswatch configuration found in npmextra.json');
+    const config = await runInit();
+    if (config) {
+      // Run with the newly created config
+      const tsWatch = new TsWatch(config);
+      await tsWatch.start();
+    }
+  }
 });
 
-tswatchCli.addCommand('element').subscribe(async (argvArg) => {
-  logger.log('info', `running watch task for a gitzone element project`);
-  const tsWatch = new TsWatch('element');
-  await tsWatch.start();
-});
-
-tswatchCli.addCommand('npm').subscribe(async (argvArg) => {
-  logger.log('info', `running watch task for a gitzone element project`);
-  const tsWatch = new TsWatch('node');
-  await tsWatch.start();
-});
-
-tswatchCli.addCommand('service').subscribe(async (argvArg) => {
-  logger.log('info', `running test task`);
-  const tsWatch = new TsWatch('service');
-  await tsWatch.start();
-});
-
-tswatchCli.addCommand('test').subscribe(async (argvArg) => {
-  logger.log('info', `running test task`);
-  const tsWatch = new TsWatch('test');
-  await tsWatch.start();
-});
-
-tswatchCli.addCommand('website').subscribe(async (argvArg) => {
-  logger.log('info', `running watch task for a gitzone website project`);
-  const tsWatch = new TsWatch('website');
-  await tsWatch.start();
+/**
+ * Init command - force run wizard (overwrite existing config)
+ */
+tswatchCli.addCommand('init').subscribe(async (argvArg) => {
+  logger.log('info', 'Running tswatch configuration wizard');
+  const config = await runInit();
+  if (config) {
+    logger.log('ok', 'Configuration created successfully');
+  }
 });
 
 export const runCli = async () => {

package/ts/tswatch.init.ts

@@ -0,0 +1,199 @@
+import * as plugins from './tswatch.plugins.js';
+import * as paths from './tswatch.paths.js';
+import * as interfaces from './interfaces/index.js';
+import { ConfigHandler } from './tswatch.classes.confighandler.js';
+import { logger } from './tswatch.logging.js';
+
+const CONFIG_KEY = '@git.zone/tswatch';
+
+/**
+ * Interactive init wizard for creating tswatch configuration
+ */
+export class TswatchInit {
+  private configHandler: ConfigHandler;
+  private smartInteract: plugins.smartinteract.SmartInteract;
+
+  constructor() {
+    this.configHandler = new ConfigHandler();
+    this.smartInteract = new plugins.smartinteract.SmartInteract([]);
+  }
+
+  /**
+   * Run the interactive init wizard
+   */
+  public async run(): Promise<interfaces.ITswatchConfig | null> {
+    console.log('\n=== tswatch Configuration Wizard ===\n');
+
+    // Ask for template choice
+    const templateAnswer = await this.smartInteract.askQuestion({
+      name: 'template',
+      type: 'list',
+      message: 'Select a configuration template:',
+      default: 'npm',
+      choices: [
+        { name: 'npm - Watch ts/ and test/, run npm test', value: 'npm' },
+        { name: 'test - Watch ts/ and test/, run npm run test2', value: 'test' },
+        { name: 'service - Watch ts/, restart npm run startTs', value: 'service' },
+        { name: 'element - Dev server + bundling for web components', value: 'element' },
+        { name: 'website - Full stack: backend + frontend + assets', value: 'website' },
+        { name: 'custom - Configure watchers manually', value: 'custom' },
+      ],
+    });
+
+    const template = templateAnswer.value as string;
+
+    let config: interfaces.ITswatchConfig;
+
+    if (template === 'custom') {
+      config = await this.runCustomWizard();
+    } else {
+      // Get preset config
+      const preset = this.configHandler.getPreset(template);
+      if (!preset) {
+        console.error(`Unknown template: ${template}`);
+        return null;
+      }
+      config = { ...preset, preset: template as interfaces.ITswatchConfig['preset'] };
+    }
+
+    // Save to npmextra.json
+    await this.saveConfig(config);
+
+    console.log('\nConfiguration saved to npmextra.json');
+    console.log('Run "tswatch" to start watching.\n');
+
+    return config;
+  }
+
+  /**
+   * Run custom configuration wizard
+   */
+  private async runCustomWizard(): Promise<interfaces.ITswatchConfig> {
+    const config: interfaces.ITswatchConfig = {};
+
+    // Ask about server
+    const serverAnswer = await this.smartInteract.askQuestion({
+      name: 'enableServer',
+      type: 'confirm',
+      message: 'Enable development server?',
+      default: false,
+    });
+
+    if (serverAnswer.value) {
+      const portAnswer = await this.smartInteract.askQuestion({
+        name: 'port',
+        type: 'input',
+        message: 'Server port:',
+        default: '3002',
+      });
+
+      const serveDirAnswer = await this.smartInteract.askQuestion({
+        name: 'serveDir',
+        type: 'input',
+        message: 'Directory to serve:',
+        default: './dist_watch/',
+      });
+
+      config.server = {
+        enabled: true,
+        port: parseInt(portAnswer.value as string, 10),
+        serveDir: serveDirAnswer.value as string,
+        liveReload: true,
+      };
+    }
+
+    // Add watchers
+    config.watchers = [];
+    let addMore = true;
+
+    while (addMore) {
+      console.log('\n--- Add a watcher ---');
+
+      const nameAnswer = await this.smartInteract.askQuestion({
+        name: 'name',
+        type: 'input',
+        message: 'Watcher name:',
+        default: `watcher-${config.watchers.length + 1}`,
+      });
+
+      const watchAnswer = await this.smartInteract.askQuestion({
+        name: 'watch',
+        type: 'input',
+        message: 'Glob pattern(s) to watch (comma-separated):',
+        default: './ts/**/*',
+      });
+
+      const commandAnswer = await this.smartInteract.askQuestion({
+        name: 'command',
+        type: 'input',
+        message: 'Command to execute:',
+        default: 'npm run test',
+      });
+
+      const restartAnswer = await this.smartInteract.askQuestion({
+        name: 'restart',
+        type: 'confirm',
+        message: 'Restart command on each change (vs queue)?',
+        default: true,
+      });
+
+      // Parse watch patterns
+      const watchPatterns = (watchAnswer.value as string)
+        .split(',')
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0);
+
+      config.watchers.push({
+        name: nameAnswer.value as string,
+        watch: watchPatterns.length === 1 ? watchPatterns[0] : watchPatterns,
+        command: commandAnswer.value as string,
+        restart: restartAnswer.value as boolean,
+        debounce: 300,
+        runOnStart: true,
+      });
+
+      const moreAnswer = await this.smartInteract.askQuestion({
+        name: 'addMore',
+        type: 'confirm',
+        message: 'Add another watcher?',
+        default: false,
+      });
+
+      addMore = moreAnswer.value as boolean;
+    }
+
+    return config;
+  }
+
+  /**
+   * Save configuration to npmextra.json
+   */
+  private async saveConfig(config: interfaces.ITswatchConfig): Promise<void> {
+    const npmextraPath = plugins.path.join(paths.cwd, 'npmextra.json');
+
+    // Read existing npmextra.json if it exists
+    let existingConfig: Record<string, any> = {};
+    try {
+      const smartfsInstance = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
+      const content = await smartfsInstance.file(npmextraPath).encoding('utf8').read() as string;
+      existingConfig = JSON.parse(content);
+    } catch {
+      // File doesn't exist or is invalid, start fresh
+    }
+
+    // Update with new tswatch config
+    existingConfig[CONFIG_KEY] = config;
+
+    // Write back
+    const smartfsInstance = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
+    await smartfsInstance.file(npmextraPath).encoding('utf8').write(JSON.stringify(existingConfig, null, 2));
+  }
+}
+
+/**
+ * Run the init wizard
+ */
+export const runInit = async (): Promise<interfaces.ITswatchConfig | null> => {
+  const init = new TswatchInit();
+  return init.run();
+};

package/ts/tswatch.plugins.ts

@@ -2,20 +2,22 @@
 import * as path from 'path';
 export { path };
 
-// @gitzone scope
+// @git.zone scope
 import * as tsbundle from '@git.zone/tsbundle';
 export { tsbundle };
 
-// @apiglobal scope
+// @api.global scope
 import * as typedserver from '@api.global/typedserver';
 
 export { typedserver };
 
-// @pushrocks scope
+// @push.rocks scope
 import * as lik from '@push.rocks/lik';
+import * as npmextra from '@push.rocks/npmextra';
 import * as smartcli from '@push.rocks/smartcli';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartfs from '@push.rocks/smartfs';
+import * as smartinteract from '@push.rocks/smartinteract';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartlogDestinationLocal from '@push.rocks/smartlog-destination-local';
 import * as smartshell from '@push.rocks/smartshell';
@@ -24,9 +26,11 @@ import * as taskbuffer from '@push.rocks/taskbuffer';
 
 export {
   lik,
+  npmextra,
   smartcli,
   smartdelay,
   smartfs,
+  smartinteract,
   smartlog,
   smartlogDestinationLocal,
   smartshell,

package/dist_ts/interfaces/interfaces.watchmodes.d.ts

@@ -1 +0,0 @@
-export type TWatchModes = 'test' | 'node' | 'service' | 'element' | 'website' | 'echo';

package/dist_ts/interfaces/interfaces.watchmodes.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy53YXRjaG1vZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaW50ZXJmYWNlcy9pbnRlcmZhY2VzLndhdGNobW9kZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/ts/interfaces/interfaces.watchmodes.ts

@@ -1 +0,0 @@
-export type TWatchModes = 'test' | 'node' | 'service' | 'element' | 'website' | 'echo';