@craftycodesmith/plug-and-play-logger 1.0.0

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlugPlayLogger = void 0;
+const path_1 = __importDefault(require("path"));
+const interceptor_js_1 = require("./interceptor.js");
+const writer_js_1 = require("./writer.js");
+class PlugPlayLogger {
+    static init(config = {}) {
+        const dir = config.dir || path_1.default.join(process.cwd(), 'logs');
+        const filename = config.filename || 'app.log';
+        this.writer = new writer_js_1.FileWriter(dir, filename);
+        if (config.intercept) {
+            (0, interceptor_js_1.patchStreams)(this.writer);
+        }
+    }
+    static log(message) {
+        if (!this.writer) {
+            throw new Error("Logger not initialized. Call PlugPlayLogger.init() first.");
+        }
+        const timestamp = new Date().toISOString();
+        this.writer.write(`[${timestamp}] [LOG] ${message}\n`);
+    }
+}
+exports.PlugPlayLogger = PlugPlayLogger;

package/dist/interceptor.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchStreams = patchStreams;
+let cachedTimestamp = new Date().toISOString();
+// Update timestamp every 1000ms
+setInterval(() => {
+    cachedTimestamp = new Date().toISOString();
+}, 1000);
+function patchStreams(writer) {
+    const originalStdout = process.stdout.write.bind(process.stdout);
+    const originalStderr = process.stderr.write.bind(process.stderr);
+    process.stdout.write = (chunk, encoding, callback) => {
+        writer.write(`[${cachedTimestamp}] [STDOUT] ${chunk.toString()}`);
+        return originalStdout(chunk, encoding, callback);
+    };
+    process.stderr.write = (chunk, encoding, callback) => {
+        writer.write(`[${cachedTimestamp}] [STDERR] ${chunk.toString()}`);
+        return originalStderr(chunk, encoding, callback);
+    };
+}

package/dist/writer.js

@@ -0,0 +1,62 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWriter = void 0;
+// src/writer.ts
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class FileWriter {
+    constructor(logDir, filename) {
+        this.logDir = logDir;
+        this.filename = filename;
+        this.buffer = [];
+        this.bufferLimit = 50; // Max logs before flush
+        if (!fs.existsSync(logDir))
+            fs.mkdirSync(logDir, { recursive: true });
+        this.stream = fs.createWriteStream(path.join(this.logDir, this.filename), { flags: 'a' });
+        // Auto-flush every 2 seconds if buffer isn't full
+        this.flushInterval = setInterval(() => this.flush(), 2000);
+    }
+    write(data) {
+        this.buffer.push(data);
+        if (this.buffer.length >= this.bufferLimit) {
+            this.flush();
+        }
+    }
+    flush() {
+        if (this.buffer.length === 0)
+            return;
+        const chunk = this.buffer.join('');
+        this.buffer = []; // Clear buffer
+        this.stream.write(chunk);
+    }
+    // Ensure logs are written before app crashes/exits
+    forceShutdown() {
+        clearInterval(this.flushInterval);
+        this.flush();
+        this.stream.end();
+    }
+}
+exports.FileWriter = FileWriter;

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@craftycodesmith/plug-and-play-logger",
+  "version": "1.0.0",
+  "description": "A zero-config stream-intercepting logger for Node.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.8"
+  }
+}