myaidev-method 0.2.23 → 0.2.24-2

package/src/scripts/utils/file-utils.js

@@ -0,0 +1,404 @@
+/**
+ * File Utilities
+ * Common file system operations for MyAIDev Method CLI
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from './logger.js';
+
+/**
+ * Read and parse a configuration file (JSON or YAML-like)
+ * @param {string} filePath - Path to config file
+ * @returns {Promise<Object|null>} Parsed config or null if not found
+ */
+export async function readConfigFile(filePath) {
+  try {
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+      logger.debug(`Config file not found: ${filePath}`);
+      return null;
+    }
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    const ext = path.extname(filePath).toLowerCase();
+
+    if (ext === '.json') {
+      return JSON.parse(content);
+    }
+
+    // For simple key=value or YAML-like files
+    if (ext === '.env' || ext === '') {
+      return parseEnvContent(content);
+    }
+
+    // Try JSON parse for unknown extensions
+    try {
+      return JSON.parse(content);
+    } catch {
+      return { raw: content };
+    }
+  } catch (error) {
+    logger.error(`Failed to read config file ${filePath}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Write a configuration file
+ * @param {string} filePath - Path to write to
+ * @param {Object|string} content - Content to write
+ * @param {Object} [options] - Write options
+ * @param {boolean} [options.pretty=true] - Pretty print JSON
+ * @param {boolean} [options.backup=false] - Create backup before overwriting
+ */
+export async function writeConfigFile(filePath, content, options = {}) {
+  const { pretty = true, backup = false } = options;
+
+  try {
+    // Create backup if requested and file exists
+    if (backup && await fs.pathExists(filePath)) {
+      await backupFile(filePath);
+    }
+
+    // Ensure directory exists
+    await fs.ensureDir(path.dirname(filePath));
+
+    const ext = path.extname(filePath).toLowerCase();
+    let output;
+
+    if (ext === '.json') {
+      output = pretty ? JSON.stringify(content, null, 2) : JSON.stringify(content);
+    } else if (ext === '.env' || filePath.includes('.env')) {
+      output = formatEnvContent(content);
+    } else if (typeof content === 'string') {
+      output = content;
+    } else {
+      output = pretty ? JSON.stringify(content, null, 2) : JSON.stringify(content);
+    }
+
+    await fs.writeFile(filePath, output, 'utf-8');
+    logger.debug(`Wrote config file: ${filePath}`);
+    return true;
+  } catch (error) {
+    logger.error(`Failed to write config file ${filePath}: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Create a backup of a file
+ * @param {string} filePath - File to backup
+ * @param {string} [backupDir] - Optional backup directory (defaults to same directory)
+ * @returns {Promise<string|null>} Backup file path or null on failure
+ */
+export async function backupFile(filePath, backupDir) {
+  try {
+    const exists = await fs.pathExists(filePath);
+    if (!exists) {
+      logger.warn(`Cannot backup non-existent file: ${filePath}`);
+      return null;
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const basename = path.basename(filePath);
+    const dirname = backupDir || path.dirname(filePath);
+
+    await fs.ensureDir(dirname);
+
+    const backupPath = path.join(dirname, `${basename}.backup-${timestamp}`);
+    await fs.copy(filePath, backupPath);
+
+    logger.debug(`Created backup: ${backupPath}`);
+    return backupPath;
+  } catch (error) {
+    logger.error(`Failed to backup file ${filePath}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Ensure a directory exists, creating it if necessary
+ * @param {string} dirPath - Directory path
+ * @returns {Promise<boolean>} True if successful
+ */
+export async function ensureDir(dirPath) {
+  try {
+    await fs.ensureDir(dirPath);
+    return true;
+  } catch (error) {
+    logger.error(`Failed to create directory ${dirPath}: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Copy a file tree from source to destination
+ * @param {string} source - Source directory
+ * @param {string} dest - Destination directory
+ * @param {Object} [options] - Copy options
+ * @param {string[]} [options.exclude] - Patterns to exclude
+ * @param {boolean} [options.overwrite=true] - Overwrite existing files
+ */
+export async function copyFileTree(source, dest, options = {}) {
+  const { exclude = [], overwrite = true } = options;
+
+  try {
+    await fs.copy(source, dest, {
+      overwrite,
+      filter: (src) => {
+        const relativePath = path.relative(source, src);
+        return !exclude.some(pattern => {
+          if (pattern.includes('*')) {
+            const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+            return regex.test(relativePath);
+          }
+          return relativePath.includes(pattern);
+        });
+      }
+    });
+    logger.debug(`Copied ${source} to ${dest}`);
+    return true;
+  } catch (error) {
+    logger.error(`Failed to copy file tree: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Read an .env file
+ * @param {string} envPath - Path to .env file
+ * @returns {Promise<Object>} Environment variables as object
+ */
+export async function readEnvFile(envPath) {
+  try {
+    const exists = await fs.pathExists(envPath);
+    if (!exists) {
+      return {};
+    }
+
+    const content = await fs.readFile(envPath, 'utf-8');
+    return parseEnvContent(content);
+  } catch (error) {
+    logger.error(`Failed to read .env file ${envPath}: ${error.message}`);
+    return {};
+  }
+}
+
+/**
+ * Write an .env file
+ * @param {string} envPath - Path to .env file
+ * @param {Object} config - Environment variables to write
+ * @param {boolean} [merge=true] - Merge with existing values
+ */
+export async function writeEnvFile(envPath, config, merge = true) {
+  try {
+    let existing = {};
+    if (merge) {
+      existing = await readEnvFile(envPath);
+    }
+
+    const merged = { ...existing, ...config };
+    const content = formatEnvContent(merged);
+
+    await fs.ensureDir(path.dirname(envPath));
+    await fs.writeFile(envPath, content, 'utf-8');
+
+    logger.debug(`Wrote .env file: ${envPath}`);
+    return true;
+  } catch (error) {
+    logger.error(`Failed to write .env file ${envPath}: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Parse .env file content into object
+ * @param {string} content - File content
+ * @returns {Object} Parsed environment variables
+ */
+function parseEnvContent(content) {
+  const result = {};
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Skip empty lines and comments
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue;
+    }
+
+    const match = trimmed.match(/^([^=]+)=(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      let value = match[2].trim();
+
+      // Remove quotes if present
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Format object as .env file content
+ * @param {Object} config - Configuration object
+ * @returns {string} Formatted .env content
+ */
+function formatEnvContent(config) {
+  const lines = [];
+
+  for (const [key, value] of Object.entries(config)) {
+    if (value === undefined || value === null) {
+      continue;
+    }
+
+    // Quote values that contain spaces or special characters
+    const stringValue = String(value);
+    const needsQuotes = stringValue.includes(' ') ||
+                       stringValue.includes('#') ||
+                       stringValue.includes('=');
+
+    if (needsQuotes) {
+      lines.push(`${key}="${stringValue}"`);
+    } else {
+      lines.push(`${key}=${stringValue}`);
+    }
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+/**
+ * Check if a path is a file
+ * @param {string} filePath - Path to check
+ * @returns {Promise<boolean>}
+ */
+export async function isFile(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a path is a directory
+ * @param {string} dirPath - Path to check
+ * @returns {Promise<boolean>}
+ */
+export async function isDirectory(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Find files matching a pattern in a directory
+ * @param {string} dirPath - Directory to search
+ * @param {string|RegExp} pattern - Pattern to match
+ * @param {Object} [options] - Search options
+ * @param {boolean} [options.recursive=true] - Search recursively
+ * @returns {Promise<string[]>} Array of matching file paths
+ */
+export async function findFiles(dirPath, pattern, options = {}) {
+  const { recursive = true } = options;
+  const results = [];
+
+  try {
+    const exists = await fs.pathExists(dirPath);
+    if (!exists) {
+      return results;
+    }
+
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+
+      if (entry.isFile()) {
+        const matches = typeof pattern === 'string'
+          ? entry.name.includes(pattern) || entry.name.endsWith(pattern)
+          : pattern.test(entry.name);
+
+        if (matches) {
+          results.push(fullPath);
+        }
+      } else if (entry.isDirectory() && recursive) {
+        const subResults = await findFiles(fullPath, pattern, options);
+        results.push(...subResults);
+      }
+    }
+
+    return results;
+  } catch (error) {
+    logger.error(`Failed to find files in ${dirPath}: ${error.message}`);
+    return results;
+  }
+}
+
+/**
+ * Get the project root directory (where package.json is)
+ * @param {string} [startDir] - Starting directory
+ * @returns {Promise<string|null>} Project root or null
+ */
+export async function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+
+  while (currentDir !== path.dirname(currentDir)) {
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    if (await fs.pathExists(packageJsonPath)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  return null;
+}
+
+/**
+ * Safely remove a file or directory
+ * @param {string} targetPath - Path to remove
+ * @returns {Promise<boolean>} True if successful
+ */
+export async function safeRemove(targetPath) {
+  try {
+    const exists = await fs.pathExists(targetPath);
+    if (!exists) {
+      return true;
+    }
+
+    await fs.remove(targetPath);
+    logger.debug(`Removed: ${targetPath}`);
+    return true;
+  } catch (error) {
+    logger.error(`Failed to remove ${targetPath}: ${error.message}`);
+    return false;
+  }
+}
+
+export default {
+  readConfigFile,
+  writeConfigFile,
+  backupFile,
+  ensureDir,
+  copyFileTree,
+  readEnvFile,
+  writeEnvFile,
+  isFile,
+  isDirectory,
+  findFiles,
+  findProjectRoot,
+  safeRemove
+};

package/src/scripts/utils/logger.js

@@ -0,0 +1,300 @@
+/**
+ * Logger Utility
+ * Provides consistent logging, formatting, and progress tracking
+ * Used across all MyAIDev Method CLI scripts
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+
+// Log levels
+const LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  SILENT: 4
+};
+
+// Current log level (can be set via environment variable)
+let currentLogLevel = LOG_LEVELS[process.env.LOG_LEVEL?.toUpperCase()] ?? LOG_LEVELS.INFO;
+
+/**
+ * Set the log level
+ * @param {string} level - Log level (DEBUG, INFO, WARN, ERROR, SILENT)
+ */
+export function setLogLevel(level) {
+  const upperLevel = level.toUpperCase();
+  if (LOG_LEVELS[upperLevel] !== undefined) {
+    currentLogLevel = LOG_LEVELS[upperLevel];
+  }
+}
+
+/**
+ * Logger object with methods for different log levels
+ */
+export const logger = {
+  /**
+   * Log debug message (only shown when LOG_LEVEL=DEBUG)
+   * @param {string} message - Debug message
+   * @param {...any} args - Additional arguments
+   */
+  debug(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.DEBUG) {
+      console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
+    }
+  },
+
+  /**
+   * Log info message
+   * @param {string} message - Info message
+   * @param {...any} args - Additional arguments
+   */
+  info(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.INFO) {
+      console.log(chalk.blue('ℹ'), message, ...args);
+    }
+  },
+
+  /**
+   * Log success message
+   * @param {string} message - Success message
+   * @param {...any} args - Additional arguments
+   */
+  success(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.INFO) {
+      console.log(chalk.green('✓'), message, ...args);
+    }
+  },
+
+  /**
+   * Log warning message
+   * @param {string} message - Warning message
+   * @param {...any} args - Additional arguments
+   */
+  warn(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.WARN) {
+      console.log(chalk.yellow('⚠'), chalk.yellow(message), ...args);
+    }
+  },
+
+  /**
+   * Log error message
+   * @param {string} message - Error message
+   * @param {...any} args - Additional arguments
+   */
+  error(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.ERROR) {
+      console.error(chalk.red('✗'), chalk.red(message), ...args);
+    }
+  },
+
+  /**
+   * Log a plain message without prefix
+   * @param {string} message - Message
+   * @param {...any} args - Additional arguments
+   */
+  log(message, ...args) {
+    if (currentLogLevel <= LOG_LEVELS.INFO) {
+      console.log(message, ...args);
+    }
+  },
+
+  /**
+   * Log a blank line
+   */
+  blank() {
+    if (currentLogLevel <= LOG_LEVELS.INFO) {
+      console.log();
+    }
+  },
+
+  /**
+   * Log a header/title
+   * @param {string} title - Header text
+   */
+  header(title) {
+    if (currentLogLevel <= LOG_LEVELS.INFO) {
+      console.log();
+      console.log(chalk.bold.cyan(`═══ ${title} ═══`));
+      console.log();
+    }
+  },
+
+  /**
+   * Log a section divider
+   * @param {string} title - Section title
+   */
+  section(title) {
+    if (currentLogLevel <= LOG_LEVELS.INFO) {
+      console.log();
+      console.log(chalk.bold(`── ${title} ──`));
+    }
+  }
+};
+
+/**
+ * Format data as a table
+ * @param {Array<Object>} data - Array of objects to display
+ * @param {Array<{key: string, header: string, width?: number}>} columns - Column definitions
+ * @returns {string} Formatted table string
+ */
+export function formatTable(data, columns) {
+  if (!data || data.length === 0) {
+    return '';
+  }
+
+  // Calculate column widths
+  const widths = columns.map(col => {
+    if (col.width) return col.width;
+    const headerLen = col.header.length;
+    const maxDataLen = Math.max(...data.map(row => String(row[col.key] ?? '').length));
+    return Math.max(headerLen, maxDataLen);
+  });
+
+  // Build header row
+  const headerRow = columns.map((col, i) =>
+    chalk.bold(col.header.padEnd(widths[i]))
+  ).join(' │ ');
+
+  // Build separator
+  const separator = widths.map(w => '─'.repeat(w)).join('─┼─');
+
+  // Build data rows
+  const dataRows = data.map(row =>
+    columns.map((col, i) =>
+      String(row[col.key] ?? '').padEnd(widths[i])
+    ).join(' │ ')
+  );
+
+  return [headerRow, separator, ...dataRows].join('\n');
+}
+
+/**
+ * Format items as a list
+ * @param {Array<string>} items - Items to list
+ * @param {string} [prefix='•'] - List item prefix
+ * @returns {string} Formatted list string
+ */
+export function formatList(items, prefix = '•') {
+  return items.map(item => `  ${prefix} ${item}`).join('\n');
+}
+
+/**
+ * Progress tracker for multi-step operations
+ */
+export class ProgressTracker {
+  constructor(total, label = 'Progress') {
+    this.total = total;
+    this.current = 0;
+    this.label = label;
+    this.failures = [];
+    this.startTime = Date.now();
+  }
+
+  /**
+   * Start the progress tracker
+   */
+  start() {
+    logger.info(`${this.label}: Starting (${this.total} items)`);
+  }
+
+  /**
+   * Increment progress
+   * @param {string} [item] - Current item being processed
+   */
+  increment(item) {
+    this.current++;
+    if (item && currentLogLevel <= LOG_LEVELS.DEBUG) {
+      logger.debug(`[${this.current}/${this.total}] ${item}`);
+    }
+  }
+
+  /**
+   * Record a failure
+   * @param {string} item - Item that failed
+   * @param {Error|string} error - Error information
+   */
+  fail(item, error) {
+    this.failures.push({ item, error: error?.message || error });
+    logger.warn(`Failed: ${item}`);
+  }
+
+  /**
+   * Complete the progress tracker
+   * @returns {{success: number, failed: number, duration: number}}
+   */
+  complete() {
+    const duration = Date.now() - this.startTime;
+    const success = this.current - this.failures.length;
+
+    logger.blank();
+    if (this.failures.length === 0) {
+      logger.success(`${this.label}: Completed ${this.current}/${this.total} items (${duration}ms)`);
+    } else {
+      logger.warn(`${this.label}: ${success} succeeded, ${this.failures.length} failed (${duration}ms)`);
+      this.failures.forEach(f => logger.error(`  - ${f.item}: ${f.error}`));
+    }
+
+    return { success, failed: this.failures.length, duration };
+  }
+}
+
+/**
+ * Create a spinner for async operations
+ * @param {string} message - Spinner message
+ * @returns {ora.Ora} Ora spinner instance
+ */
+export function createSpinner(message) {
+  return ora({
+    text: message,
+    spinner: 'dots',
+    color: 'cyan'
+  });
+}
+
+/**
+ * Wrap an async function with a spinner
+ * @param {string} message - Spinner message
+ * @param {Function} fn - Async function to execute
+ * @returns {Promise<any>} Result of the function
+ */
+export async function withSpinner(message, fn) {
+  const spinner = createSpinner(message);
+  spinner.start();
+
+  try {
+    const result = await fn();
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+}
+
+/**
+ * Format bytes to human-readable string
+ * @param {number} bytes - Number of bytes
+ * @returns {string} Human-readable string (e.g., "1.5 MB")
+ */
+export function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+
+/**
+ * Format duration to human-readable string
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Human-readable string (e.g., "2.5s")
+ */
+export function formatDuration(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  return `${(ms / 60000).toFixed(1)}m`;
+}
+
+export default logger;