rootless-config 1.0.0

package/src/utils/debounce.js

@@ -0,0 +1,22 @@
+/*-------- Generic debounce utility --------*/
+
+function debounce(fn, delay) {
+  let timer = null
+
+  function debounced(...args) {
+    clearTimeout(timer)
+    timer = setTimeout(() => {
+      timer = null
+      fn(...args)
+    }, delay)
+  }
+
+  debounced.cancel = () => {
+    clearTimeout(timer)
+    timer = null
+  }
+
+  return debounced
+}
+
+export { debounce }

package/src/utils/fsUtils.js

@@ -0,0 +1,48 @@
+/*-------- Atomic filesystem helpers — all operations are async --------*/
+
+import { createWriteStream, createReadStream } from 'node:fs'
+import { rename, mkdir, access, constants, writeFile, readFile, rm } from 'node:fs/promises'
+import path from 'node:path'
+import { pipeline } from 'node:stream/promises'
+
+async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true })
+}
+
+async function atomicWrite(targetPath, content) {
+  const tmp = `${targetPath}.tmp`
+  await ensureDir(path.dirname(targetPath))
+  await writeFile(tmp, content, 'utf8')
+  await rename(tmp, targetPath)
+}
+
+async function readJsonFile(filePath) {
+  const raw = await readFile(filePath, 'utf8')
+  return JSON.parse(raw)
+}
+
+async function writeJsonFile(filePath, data) {
+  await atomicWrite(filePath, JSON.stringify(data, null, 2))
+}
+
+async function removeFile(filePath) {
+  await rm(filePath, { force: true })
+}
+
+async function copyFile(src, dest) {
+  await ensureDir(path.dirname(dest))
+  const readable = createReadStream(src)
+  const writable = createWriteStream(dest)
+  await pipeline(readable, writable)
+}
+
+export { fileExists, ensureDir, atomicWrite, readJsonFile, writeJsonFile, removeFile, copyFile }

package/src/utils/hashUtils.js

@@ -0,0 +1,24 @@
+/*-------- SHA-256 hashing utilities using native node:crypto --------*/
+
+import { createHash } from 'node:crypto'
+import { createReadStream } from 'node:fs'
+
+function hashString(content) {
+  return createHash('sha256').update(content, 'utf8').digest('hex')
+}
+
+function hashObject(obj) {
+  return hashString(JSON.stringify(obj))
+}
+
+async function hashFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash('sha256')
+    const stream = createReadStream(filePath)
+    stream.on('data', chunk => hash.update(chunk))
+    stream.on('end', () => resolve(hash.digest('hex')))
+    stream.on('error', reject)
+  })
+}
+
+export { hashString, hashObject, hashFile }

package/src/utils/logger.js

@@ -0,0 +1,34 @@
+/*-------- Leveled logger — injected via execution context, never imported globally --------*/
+
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3, silent: 4 }
+const PREFIX = '[ROOTLESS]'
+
+const COLORS = {
+  debug: '\x1b[36m',
+  info: '\x1b[32m',
+  warn: '\x1b[33m',
+  error: '\x1b[31m',
+  reset: '\x1b[0m',
+}
+
+function createLogger({ verbose = false, silent = false } = {}) {
+  const minLevel = silent ? LEVELS.silent : verbose ? LEVELS.debug : LEVELS.info
+
+  function log(level, message) {
+    if (LEVELS[level] < minLevel) return
+    const color = COLORS[level] ?? ''
+    const line = `${color}${PREFIX} ${message}${COLORS.reset}`
+    level === 'error' ? process.stderr.write(line + '\n') : process.stdout.write(line + '\n')
+  }
+
+  return {
+    debug: msg => log('debug', msg),
+    info: msg => log('info', msg),
+    warn: msg => log('warn', msg),
+    error: msg => log('error', msg),
+    success: msg => process.stdout.write(`\x1b[32m✔ ${msg}${COLORS.reset}\n`),
+    fail: msg => process.stderr.write(`\x1b[31m✖ ${msg}${COLORS.reset}\n`),
+  }
+}
+
+export { createLogger }

package/src/utils/prompt.js

@@ -0,0 +1,15 @@
+/*-------- Interactive terminal prompt via readline/promises --------*/
+
+import { createInterface } from 'node:readline/promises'
+
+async function confirm(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    const answer = await rl.question(`${message} (y/n): `)
+    return answer.trim().toLowerCase() === 'y'
+  } finally {
+    rl.close()
+  }
+}
+
+export { confirm }

package/src/watch/dirtySet.js

@@ -0,0 +1,30 @@
+/*-------- Dirty file Set with debounced flush — deduplicates watch events --------*/
+
+import { debounce } from '../utils/debounce.js'
+
+const DEBOUNCE_MS = 100
+
+function createDirtySet(onFlush) {
+  const dirty = new Set()
+
+  const flush = debounce(async () => {
+    if (dirty.size === 0) return
+    const snapshot = new Set(dirty)
+    dirty.clear()
+    await onFlush(snapshot)
+  }, DEBOUNCE_MS)
+
+  function add(filePath) {
+    dirty.add(filePath)
+    flush()
+  }
+
+  function clear() {
+    dirty.clear()
+    flush.cancel()
+  }
+
+  return { add, clear, get size() { return dirty.size } }
+}
+
+export { createDirtySet }

package/src/watch/incrementalRegeneration.js

@@ -0,0 +1,32 @@
+/*-------- Incremental regeneration — only affected files are rebuilt --------*/
+
+import path from 'node:path'
+import { resolveProjectRoot } from '../core/pathResolver.js'
+import { generateFile } from '../core/generator.js'
+
+async function runIncrementalRegeneration(changedPaths, ctx) {
+  const projectRoot = await resolveProjectRoot()
+  const results = []
+
+  for (const sourcePath of changedPaths) {
+    const plugin = ctx.pluginRegistry.resolve(sourcePath)[0] ?? null
+    const target = path.join(projectRoot, path.basename(sourcePath))
+
+    ctx.logger.info(`Changed: ${path.basename(sourcePath)}`)
+
+    const result = await generateFile({
+      source: sourcePath,
+      target,
+      mode: 'proxy',
+      plugin,
+      options: ctx.options,
+      logger: ctx.logger,
+    })
+
+    results.push(result)
+  }
+
+  return results
+}
+
+export { runIncrementalRegeneration }

package/src/watch/watcher.js

@@ -0,0 +1,38 @@
+/*-------- Chokidar wrapper — normalizes FS events and manages lifecycle --------*/
+
+import chokidar from 'chokidar'
+import path from 'node:path'
+import { EventEmitter } from 'node:events'
+
+function createWatcher(watchPaths, options = {}) {
+  const emitter = new EventEmitter()
+  let watcher = null
+
+  function start() {
+    watcher = chokidar.watch(watchPaths, {
+      ignoreInitial: options.ignoreInitial ?? true,
+      persistent: true,
+      ignored: [/(^|[/\\])\..cache/, /\.tmp$/],
+      awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 10 },
+    })
+
+    watcher.on('change', filePath => emitter.emit('change', path.normalize(filePath)))
+    watcher.on('add', filePath => emitter.emit('add', path.normalize(filePath)))
+    watcher.on('unlink', filePath => emitter.emit('unlink', path.normalize(filePath)))
+    watcher.on('error', err => emitter.emit('error', err))
+  }
+
+  async function stop() {
+    if (watcher) await watcher.close()
+    watcher = null
+  }
+
+  function on(event, cb) {
+    emitter.on(event, cb)
+    return { start, stop, on }
+  }
+
+  return { start, stop, on }
+}
+
+export { createWatcher }