envprobe 1.0.0

package/src/autocomplete.js

@@ -0,0 +1,135 @@
+/**
+ * Autocomplete functionality for REPL
+ * Provides intelligent tab completion for commands, options, and file paths
+ */
+
+import { readdirSync, statSync } from 'fs';
+import { join, dirname, basename } from 'path';
+
+/**
+ * Get autocomplete suggestions for the current input
+ */
+export function getCompletions(line) {
+  const trimmed = line.trim();
+  
+  // Command completion
+  if (trimmed.startsWith(':') || trimmed.startsWith('.')) {
+    return getCommandCompletions(trimmed.slice(1));
+  }
+  
+  // Flag completion
+  if (trimmed.includes('--')) {
+    return getFlagCompletions(trimmed);
+  }
+  
+  // Path completion
+  return getPathCompletions(trimmed);
+}
+
+/**
+ * Get command completions
+ */
+function getCommandCompletions(partial) {
+  const commands = [
+    'help',
+    'exit',
+    'quit',
+    'history',
+    'clear',
+    'config',
+    'set',
+    'get',
+    'results',
+    'last',
+    'watch',
+    'save',
+    'load',
+  ];
+  
+  return commands
+    .filter(cmd => cmd.startsWith(partial))
+    .map(cmd => `:${cmd}`);
+}
+
+/**
+ * Get flag completions
+ */
+function getFlagCompletions(line) {
+  const flags = [
+    '--env-file',
+    '--format',
+    '--fail-on',
+    '--ignore',
+    '--no-color',
+    '--quiet',
+    '--help',
+    '--version',
+    '--watch',
+    '--config',
+  ];
+  
+  const lastWord = line.split(/\s+/).pop();
+  
+  if (!lastWord.startsWith('--')) {
+    return [];
+  }
+  
+  return flags.filter(flag => flag.startsWith(lastWord));
+}
+
+/**
+ * Get path completions
+ */
+function getPathCompletions(line) {
+  try {
+    const words = line.split(/\s+/);
+    const lastWord = words[words.length - 1] || '.';
+    
+    let dir = '.';
+    let prefix = '';
+    
+    if (lastWord.includes('/') || lastWord.includes('\\')) {
+      dir = dirname(lastWord);
+      prefix = basename(lastWord);
+    } else {
+      prefix = lastWord;
+    }
+    
+    const entries = readdirSync(dir);
+    
+    return entries
+      .filter(entry => entry.startsWith(prefix))
+      .map(entry => {
+        const fullPath = join(dir, entry);
+        try {
+          const isDir = statSync(fullPath).isDirectory();
+          return isDir ? `${entry}/` : entry;
+        } catch {
+          return entry;
+        }
+      })
+      .slice(0, 20); // Limit to 20 suggestions
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Setup readline autocomplete
+ */
+export function setupAutocomplete(rl) {
+  rl.on('line', (line) => {
+    // Store in history
+    if (line.trim()) {
+      rl.history.unshift(line);
+    }
+  });
+  
+  // Custom completer function
+  const completer = (line) => {
+    const completions = getCompletions(line);
+    return [completions, line];
+  };
+  
+  return completer;
+}

package/src/cache.js

@@ -0,0 +1,114 @@
+/**
+ * Caching layer for improved performance
+ * Caches file scan results and analysis to speed up repeated runs
+ */
+
+import { createHash } from 'crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+/**
+ * Cache manager
+ */
+export class Cache {
+  constructor(namespace = 'envcheck') {
+    this.namespace = namespace;
+    this.cacheDir = join(tmpdir(), namespace);
+    this.ensureCacheDir();
+  }
+
+  ensureCacheDir() {
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+
+  getCacheKey(data) {
+    const hash = createHash('sha256');
+    hash.update(JSON.stringify(data));
+    return hash.digest('hex');
+  }
+
+  getCachePath(key) {
+    return join(this.cacheDir, `${key}.json`);
+  }
+
+  get(key, maxAge = 3600000) {
+    try {
+      const cacheKey = this.getCacheKey(key);
+      const cachePath = this.getCachePath(cacheKey);
+
+      if (!existsSync(cachePath)) {
+        return null;
+      }
+
+      const stats = statSync(cachePath);
+      const age = Date.now() - stats.mtimeMs;
+
+      if (age > maxAge) {
+        return null;
+      }
+
+      const content = readFileSync(cachePath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  set(key, value) {
+    try {
+      const cacheKey = this.getCacheKey(key);
+      const cachePath = this.getCachePath(cacheKey);
+      const content = JSON.stringify(value);
+      writeFileSync(cachePath, content, 'utf-8');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  clear() {
+    try {
+      const { readdirSync, unlinkSync } = require('fs');
+      const files = readdirSync(this.cacheDir);
+      
+      for (const file of files) {
+        unlinkSync(join(this.cacheDir, file));
+      }
+      
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  has(key) {
+    const cacheKey = this.getCacheKey(key);
+    const cachePath = this.getCachePath(cacheKey);
+    return existsSync(cachePath);
+  }
+}
+
+/**
+ * Create a cached version of a function
+ */
+export function cached(fn, options = {}) {
+  const cache = new Cache(options.namespace);
+  const maxAge = options.maxAge || 3600000;
+
+  return async function (...args) {
+    const cacheKey = { fn: fn.name, args };
+    
+    const cached = cache.get(cacheKey, maxAge);
+    if (cached !== null) {
+      return cached;
+    }
+
+    const result = await fn(...args);
+    cache.set(cacheKey, result);
+    
+    return result;
+  };
+}