@renpwn/simplelog 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RENPWN
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,295 @@
+# simpleLog
+
+> Lightweight, opinionated, **TTY-aware logger** for Node.js with progress bar, file output, safe stringify, and zero dependencies.
+
+[![NPM](https://img.shields.io/npm/v/@renpwn/simplelog)](https://www.npmjs.com/package/@renpwn/simplelog)
+[![Downloads](https://img.shields.io/npm/dm/@renpwn/simplelog)](https://www.npmjs.com/package/@renpwn/simplelog)
+[![License](https://img.shields.io/npm/l/@renpwn/simplelog)](LICENSE)
+
+---
+
+## ✨ Features
+
+- 🎨 Colored log levels (log, debug, info, warn, error)
+- 🧠 Safe stringify (object → JSON, anti crash, truncate)
+- 🕒 Timestamp with locale (`id`, `en`)
+- 📁 File logging (TXT / JSONL + auto backup)
+- 📊 Multi progress bar (TTY-aware, auto redraw)
+- 🧹 Non-TTY & CI safe
+- ⚡ Zero dependencies
+- 🧩 Modular & audit-friendly
+
+---
+
+## 📦 Installation
+
+### NPM
+```bash
+npm install @renpwn/simplelog
+```
+
+### Yarn
+```bash
+yarn add @renpwn/simplelog
+```
+
+### Git Clone
+```bash
+git clone https://github.com/renpwn/simpleLog.git
+cd simpleLog
+npm install
+```
+
+---
+
+## 🚀 Quick Start (Minimal)
+
+```js
+import { simpleLog } from '@renpwn/simplelog'
+
+const log = simpleLog()
+
+log.log('hello')
+log.info('info message')
+log.warn('warning')
+log.error('error')
+```
+
+---
+
+## 🧠 Full Usage Example
+
+### 1️⃣ Logger dengan Level, Warna & Waktu
+
+```js
+import { simpleLog } from '@renpwn/simplelog'
+
+const log = simpleLog({
+  level: 'debug',   // log | debug | info | warn | error | silent
+  color: true,      // enable ANSI color
+  time: {
+    locale: 'id',   // id | en
+    position: 'prefix' // prefix | suffix
+  }
+})
+
+log.debug('Debug message')
+log.info('Server started')
+log.warn('Memory usage high')
+log.error({ code: 500, msg: 'Fatal error' })
+```
+
+📌 **Keterangan**
+- `level` → filter minimum level yang ditampilkan
+- `color` → otomatis nonaktif jika non-TTY
+- `time` → format waktu ringkas & konsisten
+
+---
+
+### 2️⃣ Safe Stringify & Truncate
+
+```js
+const log = simpleLog({
+  truncate: {
+    maxLength: 200
+  }
+})
+
+log.info({
+  veryLongData: 'x'.repeat(1000)
+})
+```
+
+📌 Object akan di-`JSON.stringify`, dan otomatis dipotong jika terlalu panjang.
+
+---
+
+### 3️⃣ File Logging (TXT & JSONL)
+
+#### TXT (default)
+```js
+const log = simpleLog({
+  file: {
+    path: 'logs/app.log'
+  }
+})
+
+log.info('App started')
+```
+
+Output:
+```
+[2026-01-20T07:21:10.120Z] INFO App started
+```
+
+#### JSONL
+```js
+const log = simpleLog({
+  file: {
+    path: 'logs/app.json',
+    format: 'json'
+  }
+})
+```
+
+Output:
+```json
+{"time":"2026-01-20T07:21:10.120Z","level":"info","message":"App started"}
+```
+
+📌 File write aman dengan auto-backup `.bak`.
+
+---
+
+### 4️⃣ Progress Bar (Multi Slot)
+
+```js
+const log = simpleLog({
+  progress: {
+    slots: [
+      ['Scraping', { color: 'cyan' }],
+      ['DB Queue', 'auto']
+    ]
+  }
+})
+
+let i = 0
+const timer = setInterval(() => {
+  i++
+  log.updateProgress('Scraping', i, 10, 'fetching...')
+  log.updateProgress('DB Queue', i * 2, 20)
+
+  if (i >= 10) {
+    clearInterval(timer)
+    log.info('All jobs finished')
+  }
+}, 300)
+```
+
+📌 **Catatan**
+- Progress hanya muncul di TTY
+- Log biasa akan membersihkan progress lalu merender ulang
+
+---
+
+### 5️⃣ Custom Progress Theme
+
+```js
+const log = simpleLog({
+  progress: {
+    slots: ['Download'],
+    theme: {
+      size: 30,
+      filled: '█',
+      empty: '░',
+      left: '[',
+      right: ']',
+      style: { color: 'green' }
+    }
+  }
+})
+```
+
+---
+
+## 🧩 API Ringkas
+
+```js
+log.log(...args)
+log.debug(...args)
+log.info(...args)
+log.warn(...args)
+log.error(...args)
+
+log.updateProgress(name, cur, total, text?)
+log.removeProgress(name)
+```
+
+---
+
+## 🧠 Architecture
+
+### console.log
+```
+console.log()
+   ↓
+ stdout
+```
+
+❌ No level  
+❌ No file  
+❌ No progress  
+❌ No safety  
+
+---
+
+### simpleLog
+```
+simpleLog()
+   │
+   ├─ Levels (filter)
+   ├─ Time formatter
+   ├─ Safe stringify
+   ├─ ANSI formatter
+   ├─ FileSink (txt / jsonl)
+   │
+   └─ ProgressManager
+        └─ ProgressRenderer
+             ↓
+           stdout (TTY aware)
+```
+
+---
+
+## 📂 Project Structure
+
+```
+simplelog/
+├─ package.json
+└─ src/
+   ├─ index.js                # entry point (simpleLog)
+   │
+   ├─ Logger.js               # logger utama
+   ├─ Levels.js               # level & style
+   ├─ Formatter.js            # ANSI formatter
+   ├─ Stringify.js            # stringify + truncate
+   ├─ Time.js                 # time formatter
+   ├─ FileSink.js             # file logging
+   │
+   └─ Progress/
+      ├─ ProgressManager.js   # progress state
+      └─ ProgressRenderer.js  # progress bar renderer
+```
+
+---
+
+## 🧠 Design Philosophy
+
+- Small core
+- No dependency
+- Predictable output
+- Audit friendly
+- Library-first design
+
+Cocok untuk:
+- CLI tools
+- Bot WhatsApp / Telegram
+- Scraper
+- Worker / queue
+- Base library (`simpleStore`, `simpleFetch`, dll)
+
+---
+
+## 🔗 Links
+
+- GitHub  
+  https://github.com/renpwn/simpleLog
+
+- NPM  
+  https://www.npmjs.com/package/@renpwn/simplelog
+
+---
+
+## 📄 License
+
+MIT © RenPwn

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@renpwn/simplelog",
+  "version": "0.0.1",
+  "description": "Lightweight, safe, audit-friendly logger for CLI tools and long-running Node.js processes",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "logger",
+    "logging",
+    "cli",
+    "terminal",
+    "progress-bar",
+    "jsonl",
+    "ndjson",
+    "tty",
+    "node"
+  ],
+  "license": "MIT",
+  "author": "RenPwn",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/renpwn/simpleLog.git"
+  },
+  "homepage": "https://github.com/renpwn/simpleLog",
+  "bugs": {
+    "url": "https://github.com/renpwn/simpleLog/issues"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/FileSink.js

@@ -0,0 +1,51 @@
+import fs from 'fs'
+import path from 'path'
+
+export class FileSink {
+  constructor(opts = {}) {
+    if (!opts.path) {
+      this.enabled = false
+      return
+    }
+
+    this.enabled = true
+    this.format = opts.format || 'txt'   // txt | json (JSONL)
+    this.backup = opts.backup !== false
+    this.basePath = path.resolve(process.cwd(), opts.path)
+
+    fs.mkdirSync(path.dirname(this.basePath), { recursive: true })
+  }
+
+  backupFile(file) {
+    if (!this.backup || !fs.existsSync(file)) return
+    fs.copyFileSync(file, file + '.bak')
+  }
+
+  restoreFile(file) {
+    const bak = file + '.bak'
+    if (fs.existsSync(bak)) fs.copyFileSync(bak, file)
+  }
+
+  write(level, message) {
+    if (!this.enabled) return
+    const time = new Date().toISOString()
+
+    try {
+      if (this.format === 'json') {
+        this.backupFile(this.basePath)
+        fs.appendFileSync(
+          this.basePath,
+          JSON.stringify({ time, level, message }) + '\n'
+        )
+        return
+      }
+
+      fs.appendFileSync(
+        this.basePath,
+        `[${time}] ${level.toUpperCase()} ${message}\n`
+      )
+    } catch {
+      this.restoreFile(this.basePath)
+    }
+  }
+}

package/src/Formatter.js

@@ -0,0 +1,22 @@
+const COLORS = {
+  black:30, red:31, green:32, yellow:33,
+  blue:34, magenta:35, cyan:36, white:37
+}
+const BG = {
+  black:40, red:41, green:42, yellow:43,
+  blue:44, magenta:45, cyan:46, white:47
+}
+
+export function format(text, style, tty = true) {
+  if (!tty || !style) return text
+
+  const codes = []
+  if (style.bold) codes.push(1)
+  if (style.dim) codes.push(2)
+  if (style.color && COLORS[style.color]) codes.push(COLORS[style.color])
+  if (style.bg && BG[style.bg]) codes.push(BG[style.bg])
+
+  return codes.length
+    ? `\x1b[${codes.join(';')}m${text}\x1b[0m`
+    : text
+}

package/src/Levels.js

@@ -0,0 +1,20 @@
+export const LEVELS = {
+  log: 0,
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 99
+}
+
+export const LEVEL_STYLE = {
+  log: { },
+  debug: { color: 'cyan', dim: true },
+  info:  { color: 'green' },
+  warn:  { color: 'yellow', bold: true },
+  error: { color: 'white', bg: 'red', bold: true }
+}
+
+export function normalizeLevel(level = 'log') {
+  return LEVELS[level] !== undefined ? level : 'log'
+}

package/src/Logger.js

@@ -0,0 +1,117 @@
+import { LEVELS, LEVEL_STYLE, normalizeLevel } from './Levels.js'
+import { createStringifier } from './Stringify.js'
+import { formatTime } from './Time.js'
+import { format } from './Formatter.js'
+import { FileSink } from './FileSink.js'
+import { ProgressManager } from './Progress/ProgressManager.js'
+
+export class Logger {
+  constructor(opts = {}) {
+    this.level = normalizeLevel(opts.level)
+    this.color = !!opts.color
+    this.tty = process.stdout.isTTY && !process.env.CI
+
+    this.time = !!opts.time
+    this.timeLocale = opts.time?.locale || 'id'
+    this.timePos = opts.time?.position || 'prefix'
+
+    this.stringify = createStringifier(
+      opts.truncate || { maxLength: opts.maxLength }
+    )
+
+    this.file = new FileSink(opts.file || {})
+
+    this.progress = opts.progress
+      ? new ProgressManager(opts.progress.slots || [], opts.progress.theme)
+      : null
+
+    this.lastProgressLines = 0
+  }
+
+  allow(type) {
+    return LEVELS[type] >= LEVELS[this.level]
+  }
+
+  style(type, user) {
+    if (!this.color) return user
+    return { ...LEVEL_STYLE[type], ...user }
+  }
+
+  /* ================= PROGRESS API ================= */
+
+  updateProgress(name, cur, total, text) {
+    if (!this.progress) return
+    this.progress.update(name, cur, total, text)
+    this.renderProgress()
+  }
+
+  removeProgress(name) {
+    if (!this.progress) return
+    this.progress.remove(name)
+    this.renderProgress()
+  }
+
+  /* ================= RENDER CONTROL ================= */
+
+  clearProgress() {
+    if (!this.progress || !this.tty || this.lastProgressLines === 0) return
+
+    process.stdout.write(`\x1b[${this.lastProgressLines}A`)
+    for (let i = 0; i < this.lastProgressLines; i++) {
+      process.stdout.write('\x1b[2K')
+      process.stdout.write('\x1b[1B')
+    }
+    process.stdout.write(`\x1b[${this.lastProgressLines}A`)
+    this.lastProgressLines = 0
+  }
+
+  renderProgress() {
+    if (!this.progress || !this.tty) return
+
+    const snapshot = this.progress.snapshot()
+    if (!snapshot.length) return
+
+    this.clearProgress()
+
+    process.stdout.write('\n')
+    for (const p of snapshot) {
+      process.stdout.write(`${p.line}\n`)
+    }
+
+    this.lastProgressLines = snapshot.length + 1
+  }
+
+  /* ================= CORE WRITE ================= */
+
+  write(type, args, style) {
+    if (!this.allow(type)) return
+
+    const msg = args.map(this.stringify.toStr).join(' ')
+    const t = this.time ? formatTime(this.timeLocale) : null
+
+    const out =
+      t && this.timePos === 'suffix'
+        ? `${msg} | ${t}`
+        : t
+        ? `${t} ${msg}`
+        : msg
+
+    if (this.progress) {
+      this.clearProgress()
+      process.stdout.write(
+        format(out, this.style(type, style), this.tty) + '\n'
+      )
+      this.renderProgress()
+    } else {
+      console.log(format(out, this.style(type, style), this.tty))
+    }
+
+    this.file.write(type, out)
+  }
+
+  log(...a) { this.write('log', a) }
+  debug(...a) { this.write('debug', a) }
+  info(...a)  { this.write('info', a) }
+  warn(...a)  { this.write('warn', a) }
+  error(...a) { this.write('error', a) }
+}

package/src/Progress/ProgressManager.js

@@ -0,0 +1,62 @@
+import { ProgressRenderer } from './ProgressRenderer.js'
+
+export class ProgressManager {
+  constructor(slots = [], theme = {}) {
+    this.slots = slots
+    this.state = new Map()
+    this.renderer = new ProgressRenderer(theme)
+    this.theme = theme?.style || null
+  }
+
+  update(name, cur, total, text = "") {
+    this.state.set(name, {
+      cur,
+      total: total < cur ? cur : total,
+      text,
+      start: Date.now()
+    })
+  }
+
+  remove(name) {
+    this.state.delete(name)
+  }
+
+  clear() {
+    this.state.clear()
+  }
+
+  snapshot() {
+    const s = a => Array.isArray(a) ? a : []
+    
+    return this.slots.map(item => {
+      const name = s(item)[0] || item
+      const vStyle = s(item)[1] || { }
+      
+      const v = this.state.get(name) || { cur: 0, total: 0, text: '' }
+
+      const percent = v.total
+        ? Math.floor((v.cur / v.total) * 100)
+        : 0
+
+      const elapsed = v.start
+        ? Math.floor((Date.now() - v.start) / 1000)
+        : 0
+
+      const eta =
+        v.cur && v.total && elapsed
+          ? Math.floor((elapsed / v.cur) * (v.total - v.cur))
+          : null
+
+      return {
+        name,
+        cur: v.cur,
+        total: v.total,
+        percent,
+        elapsed,
+        eta,
+        //text: v.text,
+        line: this.renderer.render(name, v.cur, v.total, v.text, vStyle)
+      }
+    })
+  }
+}

package/src/Progress/ProgressRenderer.js

@@ -0,0 +1,48 @@
+import { format } from '../Formatter.js'
+
+export class ProgressRenderer {
+  constructor({ size = 20, filled = '█', empty = '░', style = {}, left = '[', right = ']'} = {}) {
+    this.size = size
+    this.filled = filled
+    this.empty = empty
+    this.style = style
+    this.left = left
+    this.right = right
+    this.tty = process.stdout.isTTY && !process.env.CI
+  }
+  
+  styleResolve(style, current, percent){
+    if(!style) return null
+    
+    //auto style
+    if (style === 'auto')
+      return percent >= 85
+        ? { color: 'red', bold: true }
+        : percent >= 45
+          ? { color: 'yellow' }
+          : { color: 'blue' }
+    
+    //format from style dual or single
+    style = Array.isArray(style) ? (current > 0 && style.length > 1 ? style[1] : style[0]) : style
+    return style && typeof style === 'object' && Object.keys(style).length ? style :  null
+  }
+
+  render(name, cur, total, text, style = {}) {
+    if (!total) total = 1
+    const percent = Math.floor((cur / total) * 100)
+    const filled = Math.min(
+      this.size,
+      Math.max(0, Math.floor(percent / 100 * this.size))
+    )
+    
+    style = this.styleResolve(style, cur, percent)
+    this.style = this.styleResolve(this.style, cur)
+    
+    const left = format(`${name} ${this.left}`, this.style, this.tty)
+    const right = format(`${this.right} ${percent}% ${text}`, this.style, this.tty)
+    const bar = format(this.filled.repeat(filled) + this.empty.repeat(this.size - filled), style, this.tty)
+    
+
+    return left + bar + right
+  }
+}

package/src/Stringify.js

@@ -0,0 +1,26 @@
+export function createStringifier(opts = {}) {
+  const enabled = opts.enabled !== false
+  const max = Number.isInteger(opts.maxLength) ? opts.maxLength : 500
+
+  function truncate(str) {
+    if (!enabled) return str
+    if (str.length > max) {
+      return str.slice(0, max) +
+        `... [TRUNCATED ${str.length - max} chars]`
+    }
+    return str
+  }
+
+  function toStr(v) {
+    if (typeof v === 'object' && v !== null) {
+      try {
+        return truncate(JSON.stringify(v, null, 2))
+      } catch {
+        return truncate(String(v))
+      }
+    }
+    return truncate(String(v))
+  }
+
+  return { toStr }
+}

package/src/Time.js

@@ -0,0 +1,17 @@
+const LOCALES = {
+  id: {
+    days: ["MIN","SEN","SEL","RAB","KAM","JUM","SAB"],
+    mons: ["JAN","FEB","MAR","APR","MEI","JUN","JUL","AGS","SEP","OKT","NOV","DES"]
+  },
+  en: {
+    days: ["SUN","MON","TUE","WED","THU","FRI","SAT"],
+    mons: ["JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"]
+  }
+}
+
+export function formatTime(locale = 'id', date = new Date()) {
+  const l = LOCALES[locale] || LOCALES.id
+  const d = date
+
+  return `${l.days[d.getDay()]}|${String(d.getDate()).padStart(2,'0')}.${l.mons[d.getMonth()]}|${d.toTimeString().split(' ')[0]}`
+}

package/src/index.js

@@ -0,0 +1,5 @@
+import { Logger } from './Logger.js'
+
+export function simpleLog(options) {
+  return new Logger(options)
+}