vibecodingmachine-core 1.0.0

package/src/utils/logger.js

@@ -0,0 +1,191 @@
+// @vibecodingmachine/core - Logger Utility
+// Provides consistent logging functionality across the core package
+
+/**
+ * Logger utility for consistent logging
+ * Provides structured logging with different levels and formatting
+ */
+export class Logger {
+  constructor(options = {}) {
+    this.level = options.level || 'info';
+    this.prefix = options.prefix || 'VibeCodingMachine';
+    this.enableTimestamp = options.enableTimestamp !== false;
+    this.enableColors = options.enableColors !== false;
+
+    // Log levels in order of priority
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3,
+      trace: 4
+    };
+  }
+
+  /**
+   * Get current timestamp
+   * @returns {string} Formatted timestamp
+   */
+  getTimestamp() {
+    if (!this.enableTimestamp) return '';
+    return new Date().toISOString();
+  }
+
+  /**
+   * Format log message
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @param {Array} args - Additional arguments
+   * @returns {string} Formatted log message
+   */
+  formatMessage(level, message, args = []) {
+    const timestamp = this.getTimestamp();
+    const timestampStr = timestamp ? `[${timestamp}] ` : '';
+    const prefixStr = this.prefix ? `[${this.prefix}] ` : '';
+    const levelStr = `[${level.toUpperCase()}] `;
+
+    let formattedMessage = `${timestampStr}${prefixStr}${levelStr}${message}`;
+
+    if (args.length > 0) {
+      formattedMessage += ' ' + args.map(arg =>
+        typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+      ).join(' ');
+    }
+
+    return formattedMessage;
+  }
+
+  /**
+   * Check if level should be logged
+   * @param {string} level - Log level to check
+   * @returns {boolean} Whether to log this level
+   */
+  shouldLog(level) {
+    return this.levels[level] <= this.levels[this.level];
+  }
+
+  /**
+   * Log error message
+   * @param {string} message - Error message
+   * @param {...any} args - Additional arguments
+   */
+  error(message, ...args) {
+    if (!this.shouldLog('error')) return;
+
+    const formattedMessage = this.formatMessage('error', message, args);
+    console.error(formattedMessage);
+  }
+
+  /**
+   * Log warning message
+   * @param {string} message - Warning message
+   * @param {...any} args - Additional arguments
+   */
+  warn(message, ...args) {
+    if (!this.shouldLog('warn')) return;
+
+    const formattedMessage = this.formatMessage('warn', message, args);
+    console.warn(formattedMessage);
+  }
+
+  /**
+   * Log info message
+   * @param {string} message - Info message
+   * @param {...any} args - Additional arguments
+   */
+  info(message, ...args) {
+    if (!this.shouldLog('info')) return;
+
+    const formattedMessage = this.formatMessage('info', message, args);
+    console.info(formattedMessage);
+  }
+
+  /**
+   * Log debug message
+   * @param {string} message - Debug message
+   * @param {...any} args - Additional arguments
+   */
+  debug(message, ...args) {
+    if (!this.shouldLog('debug')) return;
+
+    const formattedMessage = this.formatMessage('debug', message, args);
+    console.debug(formattedMessage);
+  }
+
+  /**
+   * Log trace message
+   * @param {string} message - Trace message
+   * @param {...any} args - Additional arguments
+   */
+  trace(message, ...args) {
+    if (!this.shouldLog('trace')) return;
+
+    const formattedMessage = this.formatMessage('trace', message, args);
+    console.trace(formattedMessage);
+  }
+
+  /**
+   * Log message (alias for info)
+   * @param {string} message - Log message
+   * @param {...any} args - Additional arguments
+   */
+  log(message, ...args) {
+    this.info(message, ...args);
+  }
+
+  /**
+   * Set log level
+   * @param {string} level - New log level
+   */
+  setLevel(level) {
+    if (this.levels.hasOwnProperty(level)) {
+      this.level = level;
+    } else {
+      this.warn(`Invalid log level: ${level}. Using 'info' instead.`);
+      this.level = 'info';
+    }
+  }
+
+  /**
+   * Get current log level
+   * @returns {string} Current log level
+   */
+  getLevel() {
+    return this.level;
+  }
+
+  /**
+   * Create a child logger with a specific prefix
+   * @param {string} childPrefix - Prefix for the child logger
+   * @param {Object} options - Additional options
+   * @returns {Logger} Child logger instance
+   */
+  child(childPrefix, options = {}) {
+    const fullPrefix = this.prefix ? `${this.prefix}:${childPrefix}` : childPrefix;
+    return new Logger({
+      level: this.level,
+      prefix: fullPrefix,
+      enableTimestamp: this.enableTimestamp,
+      enableColors: this.enableColors,
+      ...options
+    });
+  }
+}
+
+// Create default logger instance
+export const logger = new Logger({
+  level: process.env.NODE_ENV === 'development' ? 'debug' : 'info',
+  prefix: 'VibeCodingMachine',
+  enableTimestamp: true,
+  enableColors: true
+});
+
+// Export console methods for backward compatibility
+export const consoleLogger = {
+  log: (...args) => logger.log(...args),
+  info: (...args) => logger.info(...args),
+  warn: (...args) => logger.warn(...args),
+  error: (...args) => logger.error(...args),
+  debug: (...args) => logger.debug(...args),
+  trace: (...args) => logger.trace(...args)
+};

package/src/utils/repo-helpers.cjs

@@ -0,0 +1,120 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const { getConfigValue } = require('./config-helpers.cjs');
+
+/**
+ * Get the hostname for the current machine
+ * @returns {string} The hostname (includes .local suffix if present)
+ */
+function getHostname() {
+  return os.hostname(); // Keep full hostname including .local
+}
+
+/**
+ * Check if computer name setting is enabled
+ * Reads from shared config location (same as Electron app)
+ * @returns {Promise<boolean>} True if enabled
+ */
+async function isComputerNameEnabled() {
+  return await getConfigValue('computerNameEnabled', false);
+}
+
+/**
+ * Get the requirements filename (always uses hostname-specific file)
+ * @param {string} hostname - Optional hostname (defaults to current hostname)
+ * @param {boolean} useHostname - Optional override (deprecated, always uses hostname)
+ * @returns {Promise<string>} The requirements filename
+ */
+async function getRequirementsFilename(hostname = null, useHostname = null) {
+  // Always use hostname-specific file to ensure consistency across CLI and Electron app
+  const host = hostname || getHostname();
+  return `REQUIREMENTS-${host}.md`;
+}
+
+/**
+ * Check if .vibecodingmachine directories exist in either location
+ * @param {string} repoPath - The repository path (defaults to cwd)
+ * @returns {Promise<Object>} Status object with exists, insideExists, siblingExists, insideDir, siblingDir
+ */
+async function checkVibeCodingMachineExists(repoPath = null) {
+  try {
+    const cwd = repoPath || process.cwd();
+    const repoName = path.basename(cwd);
+    const insideDir = path.join(cwd, '.vibecodingmachine');
+    const siblingDir = path.join(path.dirname(cwd), `.vibecodingmachine-${repoName}`);
+
+    const insideExists = await fs.pathExists(insideDir);
+    const siblingExists = await fs.pathExists(siblingDir);
+
+    return {
+      exists: insideExists || siblingExists,
+      insideExists,
+      siblingExists,
+      insideDir,
+      siblingDir
+    };
+  } catch (error) {
+    return {
+      exists: false,
+      insideExists: false,
+      siblingExists: false,
+      insideDir: null,
+      siblingDir: null
+    };
+  }
+}
+
+/**
+ * Get the .vibecodingmachine directory path (checks both inside and sibling locations)
+ * @param {string} repoPath - The repository path (defaults to cwd)
+ * @returns {Promise<string|null>} The path to the .vibecodingmachine directory or null if not found
+ */
+async function getVibeCodingMachineDir(repoPath = null) {
+  const status = await checkVibeCodingMachineExists(repoPath);
+  if (status.insideExists) {
+    return status.insideDir;
+  } else if (status.siblingExists) {
+    return status.siblingDir;
+  }
+  return null;
+}
+
+/**
+ * Get the path to the REQUIREMENTS file (with hostname)
+ * @param {string} repoPath - The repository path (defaults to cwd)
+ * @param {string} hostname - Optional hostname (defaults to current hostname)
+ * @returns {Promise<string|null>} The path to the REQUIREMENTS file or null if .vibecodingmachine dir not found
+ */
+async function getRequirementsPath(repoPath = null, hostname = null) {
+  const allnightDir = await getVibeCodingMachineDir(repoPath);
+  if (!allnightDir) {
+    return null;
+  }
+  const filename = await getRequirementsFilename(hostname);
+  return path.join(allnightDir, filename);
+}
+
+/**
+ * Check if REQUIREMENTS file exists (with hostname)
+ * @param {string} repoPath - The repository path (defaults to cwd)
+ * @param {string} hostname - Optional hostname (defaults to current hostname)
+ * @returns {Promise<boolean>} True if REQUIREMENTS file exists
+ */
+async function requirementsExists(repoPath = null, hostname = null) {
+  const reqPath = await getRequirementsPath(repoPath, hostname);
+  if (!reqPath) {
+    return false;
+  }
+  return await fs.pathExists(reqPath);
+}
+
+module.exports = {
+  getHostname,
+  isComputerNameEnabled,
+  getRequirementsFilename,
+  checkVibeCodingMachineExists,
+  getVibeCodingMachineDir,
+  getRequirementsPath,
+  requirementsExists
+};

package/src/utils/repo-helpers.js

@@ -0,0 +1,120 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const { getConfigValue } = require('./config-helpers');
+
+/**
+ * Get the hostname for the current machine
+ * @returns {string} The hostname (includes .local suffix if present)
+ */
+function getHostname() {
+  return os.hostname(); // Keep full hostname including .local
+}
+
+/**
+ * Check if computer name setting is enabled
+ * Reads from shared config location (same as Electron app)
+ * @returns {Promise<boolean>} True if enabled
+ */
+async function isComputerNameEnabled() {
+  return await getConfigValue('computerNameEnabled', false);
+}
+
+/**
+ * Get the requirements filename (always uses hostname-specific file)
+ * @param {string} hostname - Optional hostname (defaults to current hostname)
+ * @param {boolean} useHostname - Optional override (deprecated, always uses hostname)
+ * @returns {Promise<string>} The requirements filename
+ */
+async function getRequirementsFilename(hostname = null, useHostname = null) {
+  // Always use hostname-specific file to ensure consistency across CLI and Electron app
+  const host = hostname || getHostname();
+  return `REQUIREMENTS-${host}.md`;
+}
+
+/**
+ * Check if .vibecodingmachine directories exist in either location
+ * @param {string} repoPath - The repository path (defaults to cwd)
+ * @returns {Promise<Object>} Status object with exists, insideExists, siblingExists, insideDir, siblingDir
+ */
+async function checkVibeCodingMachineExists(repoPath = null) {
+  try {
+    const cwd = repoPath || process.cwd();
+    const repoName = path.basename(cwd);
+    const insideDir = path.join(cwd, '.vibecodingmachine');
+    const siblingDir = path.join(path.dirname(cwd), `.vibecodingmachine-${repoName}`);
+
+    const insideExists = await fs.pathExists(insideDir);
+    const siblingExists = await fs.pathExists(siblingDir);
+
+    return {
+      exists: insideExists || siblingExists,
+      insideExists,
+      siblingExists,
+      insideDir,
+      siblingDir
+    };
+  } catch (error) {
+    return {
+      exists: false,
+      insideExists: false,
+      siblingExists: false,
+      insideDir: null,
+      siblingDir: null
+    };
+  }
+}
+
+/**
+ * Get the .vibecodingmachine directory path (checks both inside and sibling locations)
+ * @param {string} repoPath - The repository path (defaults to cwd)
+ * @returns {Promise<string|null>} The path to the .vibecodingmachine directory or null if not found
+ */
+async function getVibeCodingMachineDir(repoPath = null) {
+  const status = await checkVibeCodingMachineExists(repoPath);
+  if (status.insideExists) {
+    return status.insideDir;
+  } else if (status.siblingExists) {
+    return status.siblingDir;
+  }
+  return null;
+}
+
+/**
+ * Get the path to the REQUIREMENTS file (with hostname)
+ * @param {string} repoPath - The repository path (defaults to cwd)
+ * @param {string} hostname - Optional hostname (defaults to current hostname)
+ * @returns {Promise<string|null>} The path to the REQUIREMENTS file or null if .vibecodingmachine dir not found
+ */
+async function getRequirementsPath(repoPath = null, hostname = null) {
+  const allnightDir = await getVibeCodingMachineDir(repoPath);
+  if (!allnightDir) {
+    return null;
+  }
+  const filename = await getRequirementsFilename(hostname);
+  return path.join(allnightDir, filename);
+}
+
+/**
+ * Check if REQUIREMENTS file exists (with hostname)
+ * @param {string} repoPath - The repository path (defaults to cwd)
+ * @param {string} hostname - Optional hostname (defaults to current hostname)
+ * @returns {Promise<boolean>} True if REQUIREMENTS file exists
+ */
+async function requirementsExists(repoPath = null, hostname = null) {
+  const reqPath = await getRequirementsPath(repoPath, hostname);
+  if (!reqPath) {
+    return false;
+  }
+  return await fs.pathExists(reqPath);
+}
+
+module.exports = {
+  getHostname,
+  isComputerNameEnabled,
+  getRequirementsFilename,
+  checkVibeCodingMachineExists,
+  getVibeCodingMachineDir,
+  getRequirementsPath,
+  requirementsExists
+};