mlld/dist/chunk-XGMRAGIT.mjs

mlld: a modular prompt scripting language

import { __name } from './chunk-OMKLS24H.mjs';
import winston, { config } from 'winston';
import path from 'path';
import fs from 'fs';

var loggingConfig = {
  // Log levels in order of increasing verbosity
  levels: config.npm.levels,
  // Color scheme for different log levels
  colors: config.npm.colors,
  // File configuration
  files: {
    directory: "logs",
    mainLog: "mlld.log",
    errorLog: "error.log",
    maxSize: 5242880,
    maxFiles: 5,
    tailable: true
  },
  // Default level based on environment
  defaultLevel: "error",
  // Format configuration
  format: {
    timestamp: "YYYY-MM-DD HH:mm:ss",
    includeTimestamp: true,
    colorize: true
  },
  // Service-specific settings
  services: {
    state: {
      level: "error",
      includeMetadata: true
    },
    parser: {
      level: "error",
      includeMetadata: true
    },
    interpreter: {
      level: "error",
      includeMetadata: true
    },
    filesystem: {
      level: "error",
      includeMetadata: true
    },
    validation: {
      level: "error",
      includeMetadata: true
    },
    output: {
      level: "error",
      includeMetadata: true
    },
    path: {
      level: "error",
      includeMetadata: true
    },
    directive: {
      level: "error",
      includeMetadata: true
    },
    circularity: {
      level: "error",
      includeMetadata: true
    },
    resolution: {
      level: "error",
      includeMetadata: true
    },
    import: {
      level: "error",
      includeMetadata: true
    },
    cli: {
      level: "error"
    },
    embed: {
      level: "error",
      includeMetadata: true
    }
  }
};
winston.addColors(loggingConfig.colors);
var consoleFormat = winston.format.combine(winston.format.timestamp({
  format: loggingConfig.format.timestamp
}), winston.format.colorize({
  all: loggingConfig.format.colorize
}), winston.format.printf(({ level, message, timestamp, service, ...metadata }) => {
  if (process.env.MLLD_DEBUG !== "true") {
    if (!level.includes("error")) {
      return "";
    }
    return `Error: ${message}`;
  }
  let msg = `${timestamp} [${level}]${service ? ` [${service}]` : ""} ${message}`;
  if (Object.keys(metadata).length > 0) {
    msg += "\n" + JSON.stringify(metadata, null, 2);
  }
  return msg;
}));
var fileFormat = winston.format.combine(winston.format.timestamp({
  format: loggingConfig.format.timestamp
}), winston.format.json());
var getLogLevel = /* @__PURE__ */ __name(() => {
  if (process.env.LOG_LEVEL) {
    return process.env.LOG_LEVEL;
  }
  if (process.env.NODE_ENV === "test") {
    return process.env.TEST_LOG_LEVEL || "error";
  }
  if (process.env.MLLD_DEBUG === "true") {
    return "debug";
  }
  return loggingConfig.defaultLevel;
}, "getLogLevel");
var _LoggerFactory = class _LoggerFactory {
  /**
  * Create a service-specific logger
  * @param serviceName The name of the service to create a logger for
  * @returns A Winston logger configured for the specified service
  */
  createServiceLogger(serviceName) {
    const serviceConfig = loggingConfig.services[serviceName];
    const getServiceLogLevel = /* @__PURE__ */ __name(() => {
      if (process.env.LOG_LEVEL) {
        return process.env.LOG_LEVEL;
      }
      if (process.env.NODE_ENV === "test") {
        return process.env.TEST_LOG_LEVEL || "error";
      }
      if (process.env.MLLD_DEBUG === "true") {
        return "debug";
      }
      return serviceConfig.level;
    }, "getServiceLogLevel");
    const logger2 = winston.createLogger({
      level: getServiceLogLevel(),
      format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
      defaultMeta: {
        service: serviceName
      },
      transports: [
        // Only use console transport outside of tests
        ...process.env.NODE_ENV === "test" ? [] : [
          new winston.transports.Console({
            format: consoleFormat,
            level: getServiceLogLevel()
          })
        ]
      ]
    });
    let currentLevel = serviceConfig.level;
    Object.defineProperty(logger2, "level", {
      get() {
        return currentLevel;
      },
      set(newLevel) {
        currentLevel = newLevel;
        logger2.transports.forEach((transport) => {
          transport.level = newLevel;
        });
      }
    });
    return logger2;
  }
};
__name(_LoggerFactory, "LoggerFactory");
var LoggerFactory = _LoggerFactory;
var loggerFactory = new LoggerFactory();
var logger = winston.createLogger({
  level: getLogLevel(),
  levels: loggingConfig.levels,
  transports: [
    // Console transport (but not during silent test)
    ...process.env.NODE_ENV === "test" && !process.env.TEST_LOG_LEVEL ? [] : [
      new winston.transports.Console({
        format: consoleFormat
      })
    ],
    // File transports only if logs directory exists (not in serverless)
    ...fs.existsSync(loggingConfig.files.directory) ? [
      // File transport for all logs
      new winston.transports.File({
        filename: path.join(loggingConfig.files.directory, loggingConfig.files.mainLog),
        format: fileFormat,
        maxsize: loggingConfig.files.maxSize,
        maxFiles: loggingConfig.files.maxFiles,
        tailable: loggingConfig.files.tailable
      }),
      // Separate file for errors
      new winston.transports.File({
        filename: path.join(loggingConfig.files.directory, loggingConfig.files.errorLog),
        level: "error",
        format: fileFormat,
        maxsize: loggingConfig.files.maxSize,
        maxFiles: loggingConfig.files.maxFiles,
        tailable: loggingConfig.files.tailable
      })
    ] : []
  ]
});
function createServiceLogger(serviceName) {
  return loggerFactory.createServiceLogger(serviceName);
}
__name(createServiceLogger, "createServiceLogger");
if (!fs.existsSync(loggingConfig.files.directory)) {
  try {
    fs.mkdirSync(loggingConfig.files.directory);
  } catch (error) {
  }
}
var stateLogger = createServiceLogger("state");
var parserLogger = createServiceLogger("parser");
var interpreterLogger = createServiceLogger("interpreter");
var filesystemLogger = createServiceLogger("filesystem");
createServiceLogger("validation");
var outputLogger = createServiceLogger("output");
var pathLogger = createServiceLogger("path");
var directiveLogger = createServiceLogger("directive");
createServiceLogger("circularity");
createServiceLogger("resolution");
createServiceLogger("import");
var cliLogger = createServiceLogger("cli");
createServiceLogger("embed");
if (process.env.NODE_ENV === "production" && fs.existsSync("logs")) {
  const fileTransport = new winston.transports.File({
    filename: "logs/error.log",
    level: "error"
  });
  [
    cliLogger,
    directiveLogger,
    interpreterLogger,
    parserLogger,
    outputLogger,
    filesystemLogger,
    pathLogger,
    stateLogger
  ].forEach((logger2) => {
    logger2.add(fileTransport);
  });
}

export { interpreterLogger, logger };
//# sourceMappingURL=chunk-XGMRAGIT.mjs.map
//# sourceMappingURL=chunk-XGMRAGIT.mjs.map