envprobe 1.0.0

package/src/utils.js

@@ -0,0 +1,57 @@
+/**
+ * Shared utility functions for envcheck-cli
+ * @module utils
+ */
+
+import path from 'path';
+
+/**
+ * Normalize a file path to use forward slashes and remove redundant separators
+ * @param {string} filePath - The file path to normalize
+ * @returns {string} The normalized file path
+ */
+export function normalizePath(filePath) {
+  if (!filePath || filePath === '') {
+    return '';
+  }
+  
+  // Use path.normalize to handle platform-specific separators and redundant separators
+  // Then convert all backslashes to forward slashes for consistency
+  return path.normalize(filePath).replace(/\\/g, '/');
+}
+
+/**
+ * Convert an absolute path to a relative path from the base directory
+ * @param {string} absolutePath - The absolute path to convert
+ * @param {string} basePath - The base directory path
+ * @returns {string} The relative path
+ */
+export function toRelativePath(absolutePath, basePath) {
+  if (!absolutePath || !basePath) {
+    return absolutePath || '';
+  }
+  
+  // If paths are the same, return '.'
+  if (path.resolve(absolutePath) === path.resolve(basePath)) {
+    return '.';
+  }
+  
+  // Use path.relative to compute relative path, then normalize to forward slashes
+  const relativePath = path.relative(basePath, absolutePath);
+  return relativePath.replace(/\\/g, '/');
+}
+
+/**
+ * Validate if a string is a valid environment variable name
+ * Must match pattern: ^[A-Z_][A-Z0-9_]*$
+ * @param {string} varName - The variable name to validate
+ * @returns {boolean} True if valid, false otherwise
+ */
+export function isValidEnvVarName(varName) {
+  if (!varName || typeof varName !== 'string') {
+    return false;
+  }
+  
+  const pattern = /^[A-Z_][A-Z0-9_]*$/;
+  return pattern.test(varName);
+}

package/src/watch.js

@@ -0,0 +1,131 @@
+/**
+ * Watch mode for continuous validation
+ * Monitors file changes and re-runs validation automatically
+ */
+
+import { watch } from 'fs';
+import { join } from 'path';
+
+/**
+ * Watch mode manager
+ */
+export class Watcher {
+  constructor(path, options, onChange) {
+    this.path = path;
+    this.options = options;
+    this.onChangeCallback = onChange;
+    this.watchers = [];
+    this.debounceTimer = null;
+    this.debounceDelay = 300;
+    this.isRunning = false;
+  }
+
+  start() {
+    console.log(`\n👀 Watching for changes in ${this.path}...`);
+    console.log('Press Ctrl+C to stop\n');
+
+    try {
+      const watcher = watch(
+        this.path,
+        { recursive: true },
+        (eventType, filename) => {
+          if (filename && this.shouldProcess(filename)) {
+            this.handleChange(eventType, filename);
+          }
+        }
+      );
+
+      this.watchers.push(watcher);
+      this.isRunning = true;
+
+      // Initial run
+      this.triggerChange('initial', 'startup');
+
+    } catch (error) {
+      console.error(`Failed to start watch mode: ${error.message}`);
+      throw error;
+    }
+  }
+
+  shouldProcess(filename) {
+    // Ignore common non-source files
+    const ignorePatterns = [
+      /node_modules/,
+      /\.git/,
+      /dist/,
+      /build/,
+      /\.log$/,
+      /\.tmp$/,
+      /~$/,
+    ];
+
+    return !ignorePatterns.some(pattern => pattern.test(filename));
+  }
+
+  handleChange(eventType, filename) {
+    // Debounce rapid changes
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    this.debounceTimer = setTimeout(() => {
+      this.triggerChange(eventType, filename);
+    }, this.debounceDelay);
+  }
+
+  async triggerChange(eventType, filename) {
+    if (this.onChangeCallback) {
+      const timestamp = new Date().toLocaleTimeString();
+      console.log(`\n[${timestamp}] Change detected: ${filename}`);
+      console.log('─'.repeat(50));
+
+      try {
+        await this.onChangeCallback();
+      } catch (error) {
+        console.error(`Error during validation: ${error.message}`);
+      }
+
+      console.log('─'.repeat(50));
+      console.log('Waiting for changes...\n');
+    }
+  }
+
+  stop() {
+    this.isRunning = false;
+    
+    for (const watcher of this.watchers) {
+      watcher.close();
+    }
+    
+    this.watchers = [];
+    
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    console.log('\n👋 Watch mode stopped');
+  }
+}
+
+/**
+ * Start watch mode
+ */
+export async function startWatchMode(path, options, runValidation) {
+  const watcher = new Watcher(path, options, runValidation);
+
+  // Handle graceful shutdown
+  process.on('SIGINT', () => {
+    watcher.stop();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', () => {
+    watcher.stop();
+    process.exit(0);
+  });
+
+  watcher.start();
+
+  // Keep process alive
+  return new Promise(() => {});
+}