@johpaz/hive-core 0.1.1

package/src/utils/logger.ts

@@ -0,0 +1,254 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export interface LoggerConfig {
+  level: LogLevel;
+  dir: string;
+  maxSizeMB: number;
+  maxFiles: number;
+  redactSensitive: boolean;
+  console: boolean;
+}
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+const SENSITIVE_PATTERNS = [
+  /api[_-]?key/i,
+  /token/i,
+  /secret/i,
+  /password/i,
+  /credential/i,
+  /auth/i,
+];
+
+const COLORS = {
+  debug: "\x1b[36m",
+  info: "\x1b[32m",
+  warn: "\x1b[33m",
+  error: "\x1b[31m",
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  bright: "\x1b[1m",
+};
+
+function expandPath(p: string): string {
+  if (p.startsWith("~")) {
+    return path.join(process.env.HOME || "", p.slice(1));
+  }
+  return p;
+}
+
+function redact(obj: unknown, seen: WeakSet<object> = new WeakSet()): unknown {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+
+  if (seen.has(obj as object)) {
+    return "[Circular]";
+  }
+
+  seen.add(obj as object);
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => redact(item, seen));
+  }
+
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    const isSensitive = SENSITIVE_PATTERNS.some((p) => p.test(key));
+    if (isSensitive) {
+      result[key] = "[REDACTED]";
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = redact(value, seen);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function formatTimestamp(): string {
+  return new Date().toISOString();
+}
+
+function formatMessage(level: LogLevel, message: string, meta?: unknown): string {
+  const timestamp = formatTimestamp();
+  const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+  return `[${timestamp}] [${level.toUpperCase()}] ${message}${metaStr}`;
+}
+
+export class Logger {
+  private config: LoggerConfig;
+  private logFile: string | null = null;
+  private currentSize = 0;
+
+  constructor(config: Partial<LoggerConfig> = {}) {
+    this.config = {
+      level: config.level ?? "info",
+      dir: config.dir ?? "~/.hive/logs",
+      maxSizeMB: config.maxSizeMB ?? 10,
+      maxFiles: config.maxFiles ?? 5,
+      redactSensitive: config.redactSensitive ?? true,
+      console: config.console ?? true,
+    };
+
+    this.initLogFile();
+  }
+
+  private initLogFile(): void {
+    const logDir = expandPath(this.config.dir);
+    
+    try {
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+
+      this.logFile = path.join(logDir, `hive-${new Date().toISOString().split("T")[0]}.log`);
+      
+      if (fs.existsSync(this.logFile)) {
+        const stats = fs.statSync(this.logFile);
+        this.currentSize = stats.size;
+      }
+    } catch {
+      this.logFile = null;
+    }
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.config.level];
+  }
+
+  private writeToConsole(level: LogLevel, message: string, meta?: unknown): void {
+    if (!this.config.console) return;
+
+    const color = COLORS[level];
+    const displayMeta = this.config.redactSensitive && meta ? redact(meta) : meta;
+    const metaStr = displayMeta ? ` ${JSON.stringify(displayMeta)}` : "";
+
+    const prefix = `${COLORS.dim}${formatTimestamp()}${COLORS.reset}`;
+    const levelStr = `${color}${COLORS.bright}[${level.toUpperCase().padEnd(5)}]${COLORS.reset}`;
+    
+    console.log(`${prefix} ${levelStr} ${message}${metaStr}`);
+  }
+
+  private writeToFile(message: string): void {
+    if (!this.logFile) return;
+
+    try {
+      const line = message + "\n";
+      const bytes = Buffer.byteLength(line);
+      
+      if (this.currentSize + bytes > this.config.maxSizeMB * 1024 * 1024) {
+        this.rotateLogs();
+      }
+
+      fs.appendFileSync(this.logFile, line);
+      this.currentSize += bytes;
+    } catch {
+      // Silently fail if we can't write to log file
+    }
+  }
+
+  private rotateLogs(): void {
+    if (!this.logFile) return;
+
+    const logDir = path.dirname(this.logFile);
+    const baseName = path.basename(this.logFile, ".log");
+
+    for (let i = this.config.maxFiles - 1; i >= 1; i--) {
+      const oldFile = path.join(logDir, `${baseName}.${i}.log`);
+      const newFile = path.join(logDir, `${baseName}.${i + 1}.log`);
+      
+      try {
+        if (fs.existsSync(oldFile)) {
+          if (i === this.config.maxFiles - 1) {
+            fs.unlinkSync(oldFile);
+          } else {
+            fs.renameSync(oldFile, newFile);
+          }
+        }
+      } catch {
+        // Continue rotation even if one file fails
+      }
+    }
+
+    try {
+      fs.renameSync(this.logFile, path.join(logDir, `${baseName}.1.log`));
+      this.currentSize = 0;
+    } catch {
+      // Continue even if rotation fails
+    }
+  }
+
+  debug(message: string, meta?: unknown): void {
+    if (!this.shouldLog("debug")) return;
+    const formatted = formatMessage("debug", message, meta);
+    this.writeToConsole("debug", message, meta);
+    this.writeToFile(formatted);
+  }
+
+  info(message: string, meta?: unknown): void {
+    if (!this.shouldLog("info")) return;
+    const formatted = formatMessage("info", message, meta);
+    this.writeToConsole("info", message, meta);
+    this.writeToFile(formatted);
+  }
+
+  warn(message: string, meta?: unknown): void {
+    if (!this.shouldLog("warn")) return;
+    const formatted = formatMessage("warn", message, meta);
+    this.writeToConsole("warn", message, meta);
+    this.writeToFile(formatted);
+  }
+
+  error(message: string, meta?: unknown): void {
+    if (!this.shouldLog("error")) return;
+    const formatted = formatMessage("error", message, meta);
+    this.writeToConsole("error", message, meta);
+    this.writeToFile(formatted);
+  }
+
+  child(context: string): ChildLogger {
+    return new ChildLogger(this, context);
+  }
+
+  setLevel(level: LogLevel): void {
+    this.config.level = level;
+  }
+}
+
+export class ChildLogger {
+  constructor(
+    private parent: Logger,
+    private context: string
+  ) {}
+
+  private prefix(message: string): string {
+    return `[${this.context}] ${message}`;
+  }
+
+  debug(message: string, meta?: unknown): void {
+    this.parent.debug(this.prefix(message), meta);
+  }
+
+  info(message: string, meta?: unknown): void {
+    this.parent.info(this.prefix(message), meta);
+  }
+
+  warn(message: string, meta?: unknown): void {
+    this.parent.warn(this.prefix(message), meta);
+  }
+
+  error(message: string, meta?: unknown): void {
+    this.parent.error(this.prefix(message), meta);
+  }
+}
+
+export const logger = new Logger();

package/src/utils/retry.ts

@@ -0,0 +1,70 @@
+export interface RetryOptions {
+  maxAttempts: number;
+  initialDelayMs: number;
+  backoffMultiplier: number;
+  maxDelayMs: number;
+}
+
+const DEFAULT_OPTIONS: RetryOptions = {
+  maxAttempts: 3,
+  initialDelayMs: 1000,
+  backoffMultiplier: 2,
+  maxDelayMs: 30000,
+};
+
+export async function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function retry<T>(
+  fn: () => Promise<T>,
+  options: Partial<RetryOptions> = {}
+): Promise<T> {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let lastError: Error | undefined;
+  let delay = opts.initialDelayMs;
+
+  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+
+      if (attempt === opts.maxAttempts) {
+        break;
+      }
+
+      await sleep(delay);
+      delay = Math.min(delay * opts.backoffMultiplier, opts.maxDelayMs);
+    }
+  }
+
+  throw lastError ?? new Error("Retry failed");
+}
+
+export async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  shouldRetry: (error: Error) => boolean,
+  options: Partial<RetryOptions> = {}
+): Promise<T> {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let lastError: Error | undefined;
+  let delay = opts.initialDelayMs;
+
+  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+
+      if (!shouldRetry(lastError) || attempt === opts.maxAttempts) {
+        break;
+      }
+
+      await sleep(delay);
+      delay = Math.min(delay * opts.backoffMultiplier, opts.maxDelayMs);
+    }
+  }
+
+  throw lastError ?? new Error("Retry failed");
+}