@tenonhq/dovetail-core 0.0.85

package/README.md

@@ -0,0 +1,6 @@
+# @tenonhq/dovetail-core
+
+This module contains the core of Dovetail. It is required to use Dovetail at all.
+It can interact with other plugins after you configure them.
+
+

package/dist/FileLogger.js

@@ -0,0 +1,207 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileLogger = void 0;
+exports.enableFileLogging = enableFileLogging;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+class FileLogger {
+    logFilePath;
+    logStream = null;
+    initialized = false;
+    constructor() {
+        // Initialize on first use
+        this.logFilePath = "";
+    }
+    /**
+     * Initialize the file logger in the current working directory
+     */
+    initialize() {
+        if (this.initialized)
+            return;
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+        const logFileName = `dovetail-debug-${timestamp}.log`;
+        // Create log file in the current working directory (ServiceNow folder)
+        this.logFilePath = path.join(process.cwd(), logFileName);
+        try {
+            // Create or append to the log file
+            this.logStream = fs.createWriteStream(this.logFilePath, { flags: 'a' });
+            this.initialized = true;
+            // Write header to log file
+            this.writeToFile(`\n${"=".repeat(80)}`);
+            this.writeToFile(`Dovetail Debug Log - Started at ${new Date().toISOString()}`);
+            this.writeToFile(`Log file: ${this.logFilePath}`);
+            this.writeToFile(`Working directory: ${process.cwd()}`);
+            this.writeToFile(`${"=".repeat(80)}\n`);
+            // Also log to console
+            console.log(chalk_1.default.cyan(`📝 Debug logging enabled: ${this.logFilePath}`));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Failed to create log file: ${error}`));
+        }
+    }
+    /**
+     * Write a message to the log file
+     */
+    writeToFile(message) {
+        if (!this.initialized) {
+            this.initialize();
+        }
+        if (this.logStream && this.logStream.writable) {
+            const timestamp = new Date().toISOString();
+            this.logStream.write(`[${timestamp}] ${message}\n`);
+        }
+    }
+    /**
+     * Format a message for both console and file output
+     */
+    formatMessage(level, message, ...args) {
+        let fullMessage = message;
+        // If there are additional arguments, stringify them
+        if (args.length > 0) {
+            const additionalInfo = args.map(arg => {
+                if (typeof arg === 'object') {
+                    try {
+                        return JSON.stringify(arg, null, 2);
+                    }
+                    catch {
+                        return String(arg);
+                    }
+                }
+                return String(arg);
+            }).join(' ');
+            fullMessage = `${message} ${additionalInfo}`;
+        }
+        return fullMessage;
+    }
+    /**
+     * Debug level logging - file only, no console output
+     */
+    debug(message, ...args) {
+        const formattedMessage = this.formatMessage('DEBUG', message, ...args);
+        this.writeToFile(`[DEBUG] ${formattedMessage}`);
+    }
+    /**
+     * Info level logging
+     */
+    info(message, ...args) {
+        const formattedMessage = this.formatMessage('INFO', message, ...args);
+        // Write to console with color
+        console.log(chalk_1.default.blue(message), ...args);
+        // Write to file
+        this.writeToFile(`[INFO] ${formattedMessage}`);
+    }
+    /**
+     * Warning level logging
+     */
+    warn(message, ...args) {
+        const formattedMessage = this.formatMessage('WARN', message, ...args);
+        // Write to console with color
+        console.log(chalk_1.default.yellow(message), ...args);
+        // Write to file
+        this.writeToFile(`[WARN] ${formattedMessage}`);
+    }
+    /**
+     * Error level logging
+     */
+    error(message, ...args) {
+        const formattedMessage = this.formatMessage('ERROR', message, ...args);
+        // Write to console with color
+        console.error(chalk_1.default.red(message), ...args);
+        // Write to file
+        this.writeToFile(`[ERROR] ${formattedMessage}`);
+    }
+    /**
+     * Success level logging
+     */
+    success(message, ...args) {
+        const formattedMessage = this.formatMessage('SUCCESS', message, ...args);
+        // Write to console with color
+        console.log(chalk_1.default.green(message), ...args);
+        // Write to file
+        this.writeToFile(`[SUCCESS] ${formattedMessage}`);
+    }
+    /**
+     * Close the log file stream
+     */
+    close() {
+        if (this.logStream) {
+            this.writeToFile(`\n${"=".repeat(80)}`);
+            this.writeToFile(`Log session ended at ${new Date().toISOString()}`);
+            this.writeToFile(`${"=".repeat(80)}\n`);
+            this.logStream.end();
+            this.logStream = null;
+            this.initialized = false;
+        }
+    }
+    /**
+     * Get the path to the current log file
+     */
+    getLogFilePath() {
+        return this.logFilePath;
+    }
+}
+// Create singleton instance
+const fileLogger = new FileLogger();
+exports.fileLogger = fileLogger;
+// Also export a function to replace console.log globally
+function enableFileLogging() {
+    // Store original console.log
+    const originalConsoleLog = console.log;
+    // Override console.log to also write to file
+    console.log = function (...args) {
+        // Call original console.log
+        originalConsoleLog.apply(console, args);
+        // Also write to file
+        const message = args.map(arg => {
+            if (typeof arg === 'object') {
+                try {
+                    return JSON.stringify(arg, null, 2);
+                }
+                catch {
+                    return String(arg);
+                }
+            }
+            return String(arg);
+        }).join(' ');
+        fileLogger.debug(message);
+    };
+    // Log that file logging is enabled
+    fileLogger.info('File logging has been enabled for this session');
+}

package/dist/FileUtils.js

@@ -0,0 +1,387 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileForce = exports.writeSNFileForce = exports.writeSNFileIfNotExists = exports.writeBuildFile = exports.summarizeFile = exports.encodedPathsToFilePaths = exports.isValidPath = exports.splitEncodedPaths = exports.getPathsInPath = exports.isDirectory = exports.toAbsolutePath = exports.getFileContextFromPath = exports.getFileContextWithSkipReason = exports.getBuildExt = exports.isUnderPath = exports.appendToPath = exports.pathExists = exports.createDirRecursively = exports.writeSNFileIfDifferent = exports.writeSNFileCurry = exports.writeScopeManifest = exports.writeManifestFile = exports.SNFileExists = void 0;
+exports.writeEnvVar = writeEnvVar;
+exports.writeEnvVars = writeEnvVars;
+const constants_1 = require("./constants");
+const fs_1 = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ConfigManager = __importStar(require("./config"));
+const FileLogger_1 = require("./FileLogger");
+const SNFileExists = (parentDirPath) => async (file) => {
+    try {
+        const files = await fs_1.promises.readdir(parentDirPath);
+        const reg = new RegExp(`${file.name}\..*$`);
+        return !!files.find((f) => reg.test(f));
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.SNFileExists = SNFileExists;
+const writeManifestFile = async (man, scope) => {
+    if (scope) {
+        const manifestPath = ConfigManager.getScopeManifestPath(scope);
+        FileLogger_1.fileLogger.debug("Writing manifest for scope " + scope + " to " + manifestPath);
+        return fs_1.promises.writeFile(manifestPath, JSON.stringify(man, null, 2));
+    }
+    const manifestPath = ConfigManager.getManifestPath();
+    FileLogger_1.fileLogger.debug("Writing manifest to " + manifestPath);
+    return fs_1.promises.writeFile(manifestPath, JSON.stringify(man, null, 2));
+};
+exports.writeManifestFile = writeManifestFile;
+const writeScopeManifest = async (scope, man) => {
+    const manifestPath = ConfigManager.getScopeManifestPath(scope);
+    FileLogger_1.fileLogger.debug("Writing scope manifest: " + scope + " -> " + manifestPath);
+    return fs_1.promises.writeFile(manifestPath, JSON.stringify(man, null, 2));
+};
+exports.writeScopeManifest = writeScopeManifest;
+const writeSNFileCurry = (checkExists) => async (file, parentPath) => {
+    let { name, type, content = "" } = file;
+    if (!content) {
+        content = "";
+    }
+    const fullPath = path_1.default.join(parentPath, `${name}.${type}`);
+    const write = async () => {
+        FileLogger_1.fileLogger.debug("Writing: " + fullPath);
+        try {
+            const result = await fs_1.promises.writeFile(fullPath, content);
+            return result;
+        }
+        catch (error) {
+            FileLogger_1.fileLogger.error("Failed to write " + fullPath + ":", error);
+            throw error;
+        }
+    };
+    if (checkExists) {
+        const exists = await (0, exports.SNFileExists)(parentPath)(file);
+        if (!exists) {
+            await write();
+        }
+        else {
+            FileLogger_1.fileLogger.debug("Skipped (exists): " + fullPath);
+        }
+    }
+    else {
+        await write();
+    }
+};
+exports.writeSNFileCurry = writeSNFileCurry;
+/**
+ * Writes the SN file to disk only if the local content differs from `file.content`.
+ * Returns `true` if the file was written (missing or differed), `false` if skipped.
+ *
+ * Used by `sinc refresh` to pull ServiceNow-side edits without churning unchanged
+ * files (preserves mtime, avoids noisy watchers, keeps diff output clean).
+ */
+const writeSNFileIfDifferent = async (file, parentPath) => {
+    let { name, type, content = "" } = file;
+    if (!content)
+        content = "";
+    const fullPath = path_1.default.join(parentPath, `${name}.${type}`);
+    let localContent = null;
+    try {
+        localContent = await fs_1.promises.readFile(fullPath, "utf8");
+    }
+    catch (e) {
+        localContent = null;
+    }
+    if (localContent === content) {
+        FileLogger_1.fileLogger.debug("Unchanged: " + fullPath);
+        return false;
+    }
+    if (localContent !== null) {
+        FileLogger_1.fileLogger.debug("Overwriting local content (differs from instance): " + fullPath);
+    }
+    else {
+        FileLogger_1.fileLogger.debug("Writing (missing locally): " + fullPath);
+    }
+    try {
+        await fs_1.promises.writeFile(fullPath, content);
+        return true;
+    }
+    catch (error) {
+        FileLogger_1.fileLogger.error("Failed to write " + fullPath + ":", error);
+        throw error;
+    }
+};
+exports.writeSNFileIfDifferent = writeSNFileIfDifferent;
+const createDirRecursively = async (path) => {
+    await fs_1.promises.mkdir(path, { recursive: true });
+};
+exports.createDirRecursively = createDirRecursively;
+const pathExists = async (path) => {
+    try {
+        await fs_1.promises.access(path, fs_1.default.constants.F_OK);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.pathExists = pathExists;
+const appendToPath = (prefix) => (suffix) => path_1.default.join(prefix, suffix);
+exports.appendToPath = appendToPath;
+/**
+ * Detects if a path is under a parent directory
+ * @param parentPath full path to parent directory
+ * @param potentialChildPath full path to child directory
+ */
+const isUnderPath = (parentPath, potentialChildPath) => {
+    const parentTokens = parentPath.split(path_1.default.sep);
+    const childTokens = potentialChildPath.split(path_1.default.sep);
+    return parentTokens.every((token, index) => token === childTokens[index]);
+};
+exports.isUnderPath = isUnderPath;
+const getFileExtension = (filePath) => {
+    try {
+        return "." + path_1.default.basename(filePath).split(".").slice(1).join(".");
+    }
+    catch (e) {
+        return "";
+    }
+};
+const getBuildExt = (table, recordName, field, scope) => {
+    var manifest = ConfigManager.getManifest();
+    if (!manifest) {
+        throw new Error("Failed to retrieve manifest");
+    }
+    var resolvedManifest = manifest;
+    if (scope && ConfigManager.isMultiScopeManifest(manifest)) {
+        var scopeMan = ConfigManager.resolveManifestForScope(manifest, scope);
+        if (!scopeMan) {
+            throw new Error("Failed to find scope " + scope + " in manifest");
+        }
+        resolvedManifest = scopeMan;
+    }
+    const files = resolvedManifest.tables[table].records[recordName].files;
+    const file = files.find((f) => f.name === field);
+    if (!file) {
+        throw new Error("Unable to find file");
+    }
+    return file.type;
+};
+exports.getBuildExt = getBuildExt;
+const getTargetFieldFromPath = (filePath, table, ext) => {
+    return table === "sys_atf_step"
+        ? "inputs.script"
+        : path_1.default.basename(filePath, ext);
+};
+const getFileContextWithSkipReason = (filePath) => {
+    const ext = getFileExtension(filePath);
+    const [tableName, recordName] = path_1.default
+        .dirname(filePath)
+        .split(path_1.default.sep)
+        .slice(-2);
+    const targetField = getTargetFieldFromPath(filePath, tableName, ext);
+    var manifest = ConfigManager.getManifest();
+    if (!manifest) {
+        throw new Error("No manifest has been loaded!");
+    }
+    var scope;
+    var tables;
+    if (ConfigManager.isMultiScopeManifest(manifest)) {
+        var detectedScope = ConfigManager.resolveScopeFromPath(filePath);
+        if (!detectedScope) {
+            return { skipReason: "scope not found" };
+        }
+        var scopeMan = ConfigManager.resolveManifestForScope(manifest, detectedScope);
+        if (!scopeMan) {
+            return { skipReason: "scope manifest not found" };
+        }
+        scope = scopeMan.scope || detectedScope;
+        tables = scopeMan.tables;
+    }
+    else {
+        scope = manifest.scope;
+        tables = manifest.tables;
+    }
+    try {
+        const { records } = tables[tableName];
+        const record = records[recordName];
+        const { files, sys_id } = record;
+        const field = files.find((file) => file.name === targetField);
+        if (!field) {
+            return { skipReason: "not in manifest" };
+        }
+        return {
+            context: {
+                filePath,
+                ext,
+                sys_id,
+                name: recordName,
+                scope,
+                tableName,
+                targetField,
+            },
+        };
+    }
+    catch (e) {
+        return { skipReason: "not in manifest" };
+    }
+};
+exports.getFileContextWithSkipReason = getFileContextWithSkipReason;
+const getFileContextFromPath = (filePath) => {
+    return (0, exports.getFileContextWithSkipReason)(filePath).context;
+};
+exports.getFileContextFromPath = getFileContextFromPath;
+const toAbsolutePath = (p) => path_1.default.isAbsolute(p) ? p : path_1.default.join(process.cwd(), p);
+exports.toAbsolutePath = toAbsolutePath;
+const isDirectory = async (p) => {
+    const stats = await fs_1.promises.stat(p);
+    return stats.isDirectory();
+};
+exports.isDirectory = isDirectory;
+const getPathsInPath = async (p) => {
+    if (!(0, exports.isUnderPath)(ConfigManager.getSourcePath(), p) &&
+        !(0, exports.isUnderPath)(ConfigManager.getBuildPath(), p)) {
+        return [];
+    }
+    const isDir = await (0, exports.isDirectory)(p);
+    if (!isDir) {
+        return [p];
+    }
+    else {
+        const childPaths = await fs_1.promises.readdir(p);
+        const pathPromises = childPaths.map((childPath) => (0, exports.getPathsInPath)(path_1.default.resolve(p, childPath)));
+        const stackedPaths = await Promise.all(pathPromises);
+        return stackedPaths.flat();
+    }
+};
+exports.getPathsInPath = getPathsInPath;
+const splitEncodedPaths = (encodedPaths) => encodedPaths.split(constants_1.PATH_DELIMITER).filter((p) => p && p !== "");
+exports.splitEncodedPaths = splitEncodedPaths;
+const isValidPath = async (path) => {
+    return (0, exports.pathExists)(path);
+};
+exports.isValidPath = isValidPath;
+const encodedPathsToFilePaths = async (encodedPaths) => {
+    const pathSplits = (0, exports.splitEncodedPaths)(encodedPaths);
+    const validChecks = await Promise.all(pathSplits.map(exports.isValidPath));
+    const validSplits = pathSplits.filter((_, index) => validChecks[index]);
+    const splitPaths = await Promise.all(validSplits.map(exports.getPathsInPath));
+    const deDupedPaths = splitPaths.flat().reduce((acc, cur) => {
+        acc.add(cur);
+        return acc;
+    }, new Set());
+    return Array.from(deDupedPaths);
+};
+exports.encodedPathsToFilePaths = encodedPathsToFilePaths;
+const summarizeFile = (ctx) => {
+    const { tableName, name: recordName, sys_id } = ctx;
+    return `${tableName}/${recordName}/${sys_id}`;
+};
+exports.summarizeFile = summarizeFile;
+const writeBuildFile = async (folderPath, newPath, fileContents) => {
+    const buildPath = ConfigManager.getBuildPath();
+    const resolvedFolder = path_1.default.resolve(folderPath);
+    const resolvedFile = path_1.default.resolve(newPath);
+    if (!(0, exports.isUnderPath)(buildPath, resolvedFolder) || !(0, exports.isUnderPath)(buildPath, resolvedFile)) {
+        throw new Error(`Write rejected: path "${resolvedFile}" is outside build directory "${buildPath}"`);
+    }
+    try {
+        await fs_1.promises.access(folderPath, fs_1.default.constants.F_OK);
+    }
+    catch (e) {
+        await fs_1.promises.mkdir(folderPath, { recursive: true });
+    }
+    await fs_1.promises.writeFile(newPath, fileContents);
+};
+exports.writeBuildFile = writeBuildFile;
+exports.writeSNFileIfNotExists = (0, exports.writeSNFileCurry)(true);
+exports.writeSNFileForce = (0, exports.writeSNFileCurry)(false);
+exports.writeFileForce = fs_1.promises.writeFile;
+// ============================================================================
+// .env File Utilities — merge-style writes (never destructive)
+// ============================================================================
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function quoteEnvValue(value) {
+    if (/[\s#"'\\]/.test(value)) {
+        return "\"" + value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n") + "\"";
+    }
+    return value;
+}
+function mergeEnvLine(content, key, value) {
+    const escaped = escapeRegex(key);
+    const regex = new RegExp("^" + escaped + "=.*$", "m");
+    const line = key + "=" + quoteEnvValue(value);
+    if (regex.test(content)) {
+        return content.replace(regex, line);
+    }
+    if (content.length > 0 && content.charAt(content.length - 1) !== "\n") {
+        content += "\n";
+    }
+    return content + line + "\n";
+}
+function readEnvFile(envPath) {
+    try {
+        return fs_1.default.readFileSync(envPath, "utf8");
+    }
+    catch (e) {
+        return "";
+    }
+}
+/**
+ * @description Writes a single env variable to a .env file, preserving existing values.
+ * @param {Object} params - Parameters object.
+ * @param {string} params.key - The environment variable name.
+ * @param {string} params.value - The value to set.
+ * @param {string} [params.envPath] - Path to .env file. Defaults to process.cwd()/.env.
+ */
+function writeEnvVar(params) {
+    const resolvedPath = params.envPath || path_1.default.resolve(process.cwd(), ".env");
+    const content = mergeEnvLine(readEnvFile(resolvedPath), params.key, params.value);
+    fs_1.default.writeFileSync(resolvedPath, content, "utf8");
+}
+/**
+ * @description Writes multiple env variables to a .env file in a single read/write cycle.
+ * @param {Object} params - Parameters object.
+ * @param {Array<{key: string; value: string}>} params.vars - Array of key/value pairs to write.
+ * @param {string} [params.envPath] - Path to .env file. Defaults to process.cwd()/.env.
+ */
+function writeEnvVars(params) {
+    const resolvedPath = params.envPath || path_1.default.resolve(process.cwd(), ".env");
+    let content = readEnvFile(resolvedPath);
+    params.vars.forEach(({ key, value }) => {
+        content = mergeEnvLine(content, key, value);
+    });
+    fs_1.default.writeFileSync(resolvedPath, content, "utf8");
+}

package/dist/Logger.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const winston_1 = __importStar(require("winston"));
+const chalk_1 = __importDefault(require("chalk"));
+class SincLogger {
+    logger;
+    constructor() {
+        this.logger = winston_1.default.createLogger(this.genLoggerOpts());
+    }
+    setLogLevel(level) {
+        this.logger = winston_1.default.createLogger(this.genLoggerOpts(level));
+    }
+    getLogLevel() {
+        return this.logger.level;
+    }
+    genLoggerOpts(level = "info") {
+        return {
+            format: winston_1.format.printf(info => {
+                return `${info.message}`;
+            }),
+            level,
+            transports: [new winston_1.transports.Console()]
+        };
+    }
+    info(text) {
+        this.logger.info(chalk_1.default.blue(text));
+    }
+    error(text) {
+        this.logger.error(chalk_1.default.red(text));
+    }
+    warn(text) {
+        this.logger.warn(chalk_1.default.yellow(text));
+    }
+    success(text) {
+        this.logger.info(chalk_1.default.green(text));
+    }
+    verbose(text) {
+        this.logger.verbose(text);
+    }
+    debug(text) {
+        this.logger.debug(text);
+    }
+    silly(text) {
+        this.logger.silly(text);
+    }
+    getInternalLogger() {
+        return this.logger;
+    }
+}
+const loggerInst = new SincLogger();
+exports.logger = loggerInst;