@simplens/onboard 1.0.1 → 1.0.2

package/src/utils/logger.ts

@@ -1,118 +1,144 @@
-import chalk from 'chalk';
-import { appendFile as fsAppendFile } from 'fs/promises';
-import path from 'path';
-import { FILES } from '../config/constants.js';
-
-/**
- * Logging level
- */
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-/**
- * Logger configuration
- */
-interface LoggerConfig {
-    verbose: boolean;
-    debug: boolean;
-    logFile?: string;
-}
-
-let loggerConfig: LoggerConfig = {
-    verbose: false,
-    debug: false,
-};
-
-/**
- * Initialize logger with configuration
- */
-export function initLogger(config: Partial<LoggerConfig>): void {
-    loggerConfig = { ...loggerConfig, ...config };
-}
-
-/**
- * Get current logger configuration
- */
-export function getLoggerConfig(): Readonly<LoggerConfig> {
-    return { ...loggerConfig };
-}
-
-/**
- * Write log message to file if configured
- */
-async function writeToLogFile(level: LogLevel, message: string): Promise<void> {
-    if (!loggerConfig.logFile) return;
-    
-    try {
-        const timestamp = new Date().toISOString();
-        const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-        await fsAppendFile(loggerConfig.logFile, logEntry, 'utf-8');
-    } catch (error) {
-        // Silently fail on log file errors
-    }
-}
-
-/**
- * Log debug message (only shown with --debug flag)
- */
-export function logDebug(message: string): void {
-    if (loggerConfig.debug) {
-        console.log(chalk.gray(`🔧 ${message}`));
-    }
-    writeToLogFile('debug', message);
-}
-
-/**
- * Log verbose message (shown with --verbose or --debug)
- */
-export function logVerbose(message: string): void {
-    if (loggerConfig.verbose || loggerConfig.debug) {
-        console.log(chalk.cyan(`ℹ️  ${message}`));
-    }
-    writeToLogFile('info', message);
-}
-
-/**
- * Log info message (always displayed)
- */
-export function logInfo(message: string): void {
-    console.log(chalk.blue(`ℹ️  ${message}`));
-    writeToLogFile('info', message);
-}
-
-/**
- * Log success message (always displayed)
- */
-export function logSuccess(message: string): void {
-    console.log(chalk.green(`✅ ${message}`));
-    writeToLogFile('info', message);
-}
-
-/**
- * Log warning message (always displayed)
- */
-export function logWarning(message: string): void {
-    console.log(chalk.yellow(`⚠️  ${message}`));
-    writeToLogFile('warn', message);
-}
-
-/**
- * Log error message (always displayed)
- */
-export function logError(message: string): void {
-    console.log(chalk.red(`❌ ${message}`));
-    writeToLogFile('error', message);
-}
-
-/**
- * Log command execution (debug level)
- */
-export function logCommand(command: string, args: string[]): void {
-    logDebug(`Executing: ${command} ${args.join(' ')}`);
-}
-
-/**
- * Log file operation (debug level)
- */
-export function logFileOperation(operation: string, filePath: string): void {
-    logDebug(`${operation}: ${filePath}`);
-}
+import chalk from 'chalk';
+import { appendFile as fsAppendFile } from 'fs/promises';
+
+/**
+ * Logging level
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+/**
+ * Logger configuration
+ */
+interface LoggerConfig {
+    verbose: boolean;
+    debug: boolean;
+    silent: boolean;
+    logFile?: string;
+}
+
+let loggerConfig: LoggerConfig = {
+    verbose: false,
+    debug: false,
+    silent: false,
+};
+
+function formatTag(tag: string, color: (text: string) => string): string {
+    return color(`[${tag.toUpperCase().padEnd(7)}]`);
+}
+
+function printLogLine(tag: 'debug' | 'info' | 'ok' | 'warn' | 'error', message: string): void {
+    if (loggerConfig.silent) return;
+    
+    switch (tag) {
+        case 'debug':
+            console.log(`${formatTag('debug', chalk.gray)} ${chalk.gray(message)}`);
+            return;
+        case 'info':
+            console.log(`${formatTag('info', chalk.blueBright)} ${message}`);
+            return;
+        case 'ok':
+            console.log(`${formatTag('ok', chalk.greenBright)} ${message}`);
+            return;
+        case 'warn':
+            console.log(`${formatTag('warn', chalk.yellowBright)} ${message}`);
+            return;
+        case 'error':
+            console.log(`${formatTag('error', chalk.redBright)} ${message}`);
+            return;
+    }
+}
+
+/**
+ * Initialize logger with configuration
+ */
+export function initLogger(config: Partial<LoggerConfig>): void {
+    loggerConfig = { ...loggerConfig, ...config };
+}
+
+/**
+ * Get current logger configuration
+ */
+export function getLoggerConfig(): Readonly<LoggerConfig> {
+    return { ...loggerConfig };
+}
+
+/**
+ * Write log message to file if configured
+ */
+async function writeToLogFile(level: LogLevel, message: string): Promise<void> {
+    if (!loggerConfig.logFile) return;
+
+    try {
+        const timestamp = new Date().toISOString();
+        const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+        await fsAppendFile(loggerConfig.logFile, logEntry, 'utf-8');
+    } catch (error) {
+        // Silently fail on log file errors
+    }
+}
+
+/**
+ * Log debug message (only shown with --debug flag)
+ */
+export function logDebug(message: string): void {
+    if (loggerConfig.debug) {
+        printLogLine('debug', message);
+    }
+    writeToLogFile('debug', message);
+}
+
+/**
+ * Log verbose message (shown with --verbose or --debug)
+ */
+export function logVerbose(message: string): void {
+    if (!loggerConfig.silent && (loggerConfig.verbose || loggerConfig.debug)) {
+        console.log(`${formatTag('verbose', chalk.cyanBright)} ${message}`);
+    }
+    writeToLogFile('info', message);
+}
+
+/**
+ * Log info message (always displayed)
+ */
+export function logInfo(message: string): void {
+    printLogLine('info', message);
+    writeToLogFile('info', message);
+}
+
+/**
+ * Log success message (always displayed)
+ */
+export function logSuccess(message: string): void {
+    printLogLine('ok', message);
+    writeToLogFile('info', message);
+}
+
+/**
+ * Log warning message (always displayed)
+ */
+export function logWarning(message: string): void {
+    printLogLine('warn', message);
+    writeToLogFile('warn', message);
+}
+
+/**
+ * Log error message (always displayed)
+ */
+export function logError(message: string): void {
+    printLogLine('error', message);
+    writeToLogFile('error', message);
+}
+
+/**
+ * Log command execution (debug level)
+ */
+export function logCommand(command: string, args: string[]): void {
+    logDebug(`Executing: ${command} ${args.join(' ')}`);
+}
+
+/**
+ * Log file operation (debug level)
+ */
+export function logFileOperation(operation: string, filePath: string): void {
+    logDebug(`${operation}: ${filePath}`);
+}

package/src/utils.ts

@@ -1,105 +1,183 @@
-import chalk from 'chalk';
-import { execa } from 'execa';
-import fs from 'fs/promises';
-import path from 'path';
-import figlet from 'figlet';
-
-// Re-export logger functions for backward compatibility
-export {
-    logSuccess,
-    logError,
-    logWarning,
-    logInfo,
-    logDebug,
-    logVerbose,
-    logCommand,
-    logFileOperation,
-    initLogger,
-    getLoggerConfig,
-} from './utils/logger.js';
-
-/**
- * Display SimpleNS banner in blue using figlet
- */
-export function displayBanner(): void {
-    const simpleNS = figlet.textSync('SimpleNS', {
-        font: 'Standard',
-        horizontalLayout: 'default',
-    });
-    
-    const onboard = figlet.textSync('Onboard', {
-        font: 'Standard',
-        horizontalLayout: 'default',
-    });
-
-    console.log(chalk.blue(simpleNS));
-    console.log(chalk.blue(onboard));
-    console.log('');
-}
-
-/**
- * Execute a shell command with error handling
- */
-export async function executeCommand(
-    command: string,
-    args: string[],
-    options?: { cwd?: string; silent?: boolean }
-): Promise<{ stdout: string; stderr: string }> {
-    // Import dynamically to avoid circular dependency
-    const { logCommand } = await import('./utils/logger.js');
-    
-    logCommand(command, args);
-    
-    try {
-        const result = await execa(command, args, {
-            cwd: options?.cwd || process.cwd(),
-            stdio: options?.silent ? 'pipe' : 'inherit',
-        });
-        return { stdout: result.stdout, stderr: result.stderr };
-    } catch (error: any) {
-        throw new Error(`Command failed: ${command} ${args.join(' ')}\n${error.message}`);
-    }
-}
-
-/**
- * Check if file exists
- */
-export async function fileExists(filePath: string): Promise<boolean> {
-    try {
-        await fs.access(filePath);
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-/**
- * Write file content
- */
-export async function writeFile(filePath: string, content: string): Promise<void> {
-    const { logFileOperation } = await import('./utils/logger.js');
-    
-    logFileOperation('Writing file', filePath);
-    
-    const dir = path.dirname(filePath);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(filePath, content, 'utf-8');
-}
-
-/**
- * Read file content
- */
-export async function readFile(filePath: string): Promise<string> {
-    return await fs.readFile(filePath, 'utf-8');
-}
-
-/**
- * Append content to file
- */
-export async function appendFile(filePath: string, content: string): Promise<void> {
-    // Ensure parent directory exists, similar to writeFile
-    const dir = path.dirname(filePath);
-    await fs.mkdir(dir, { recursive: true });
-    
-    await fs.appendFile(filePath, content, 'utf-8');
-}
+import chalk from 'chalk';
+import { execa } from 'execa';
+import fs from 'fs/promises';
+import path from 'path';
+import figlet from 'figlet';
+import { getLoggerConfig } from './utils/logger.js';
+
+// Re-export logger functions for backward compatibility
+export {
+    logSuccess,
+    logError,
+    logWarning,
+    logInfo,
+    logDebug,
+    logVerbose,
+    logCommand,
+    logFileOperation,
+    initLogger,
+    getLoggerConfig,
+} from './utils/logger.js';
+
+const MAX_TUI_WIDTH = 78;
+const MIN_TUI_WIDTH = 52;
+
+type AccentColor = 'blue' | 'cyan' | 'green' | 'yellow' | 'red' | 'gray';
+
+function getTerminalWidth(): number {
+    const columns = process.stdout.columns ?? MAX_TUI_WIDTH;
+    return Math.max(MIN_TUI_WIDTH, Math.min(MAX_TUI_WIDTH, columns));
+}
+
+function accent(text: string, color: AccentColor): string {
+    switch (color) {
+        case 'blue':
+            return chalk.blueBright(text);
+        case 'cyan':
+            return chalk.cyanBright(text);
+        case 'green':
+            return chalk.greenBright(text);
+        case 'yellow':
+            return chalk.yellowBright(text);
+        case 'red':
+            return chalk.redBright(text);
+        case 'gray':
+        default:
+            return chalk.gray(text);
+    }
+}
+
+export function divider(color: AccentColor = 'gray', char: string = '─'): string {
+    return accent(char.repeat(getTerminalWidth()), color);
+}
+
+export function printStepHeader(step: number, total: number, title: string): void {
+    if (getLoggerConfig().silent) return;
+    
+    const filled = '■'.repeat(Math.max(0, step));
+    const empty = '·'.repeat(Math.max(0, total - step));
+    const progress = chalk.gray(`${filled}${empty}`);
+
+    console.log(`\n${divider()}`);
+    console.log(`${accent(`[${step}/${total}]`, 'cyan')} ${chalk.whiteBright(title)} ${progress}`);
+    console.log(divider());
+}
+
+export function printSummaryCard(
+    title: string,
+    rows: Array<{ label: string; value: string }>
+): void {
+    if (getLoggerConfig().silent) return;
+    
+    const labelWidth = Math.max(...rows.map(row => row.label.length), 0);
+
+    console.log(`\n${accent(title, 'cyan')}`);
+    console.log(divider());
+    for (const row of rows) {
+        const label = chalk.gray(row.label.padEnd(labelWidth));
+        console.log(`${label}  ${chalk.white(row.value)}`);
+    }
+    console.log(`${divider()}\n`);
+}
+
+export function printCommandHints(title: string, commands: string[]): void {
+    if (getLoggerConfig().silent) return;
+    
+    console.log(accent(title, 'cyan'));
+    for (const command of commands) {
+        console.log(`  ${accent('›', 'gray')} ${chalk.white(command)}`);
+    }
+    console.log('');
+}
+
+/**
+ * Display SimpleNS banner in blue using figlet
+ */
+export function displayBanner(): void {
+    if (getLoggerConfig().silent) return;
+    
+    const simpleNS = figlet.textSync('SimpleNS', {
+        font: 'Standard',
+        horizontalLayout: 'default',
+    });
+    
+    const onboard = figlet.textSync('Onboard', {
+        font: 'Standard',
+        horizontalLayout: 'default',
+    });
+
+    console.log('');
+    console.log(divider('blue', '═'));
+    console.log(chalk.blueBright(simpleNS));
+    console.log(chalk.cyanBright(onboard));
+    console.log(chalk.gray('SimpleNS local setup assistant'));
+    console.log(divider('blue', '═'));
+    console.log('');
+}
+
+/**
+ * Execute a shell command with error handling
+ */
+export async function executeCommand(
+    command: string,
+    args: string[],
+    options?: { cwd?: string; silent?: boolean }
+): Promise<{ stdout: string; stderr: string }> {
+    // Import dynamically to avoid circular dependency
+    const { logCommand } = await import('./utils/logger.js');
+    
+    logCommand(command, args);
+    
+    try {
+        const result = await execa(command, args, {
+            cwd: options?.cwd || process.cwd(),
+            stdio: options?.silent ? 'pipe' : 'inherit',
+        });
+        return { stdout: result.stdout, stderr: result.stderr };
+    } catch (error: any) {
+        throw new Error(`Command failed: ${command} ${args.join(' ')}\n${error.message}`);
+    }
+}
+
+/**
+ * Check if file exists
+ */
+export async function fileExists(filePath: string): Promise<boolean> {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Write file content
+ */
+export async function writeFile(filePath: string, content: string): Promise<void> {
+    const { logFileOperation } = await import('./utils/logger.js');
+    
+    logFileOperation('Writing file', filePath);
+    
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+
+/**
+ * Read file content
+ */
+export async function readFile(filePath: string): Promise<string> {
+    return await fs.readFile(filePath, 'utf-8');
+}
+
+/**
+ * Append content to file
+ */
+export async function appendFile(filePath: string, content: string): Promise<void> {
+    // Ensure parent directory exists, similar to writeFile
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    
+    await fs.appendFile(filePath, content, 'utf-8');
+}