cra-audit 0.1.0

package/src/utils/fs.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/** Reads and parses a JSON file. Returns null if it does not exist. */
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, 'utf8');
+  return JSON.parse(content);
+}
+
+/** Writes a JSON object to disk with 2-space indentation. */
+function writeJson(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+
+/** Returns true if a path exists. */
+function exists(filePath) {
+  return fs.existsSync(filePath);
+}
+
+/**
+ * Resolves the project root by locating the nearest package.json,
+ * walking up from the provided starting directory.
+ */
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = path.resolve(startDir);
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+module.exports = { readJson, writeJson, exists, findProjectRoot };

package/src/utils/http.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * Tiny HTTP helper built on the global `fetch` (Node >= 18).
+ * Adds a per-request timeout and never throws: failures resolve to null so
+ * enrichment can degrade gracefully when offline or rate-limited.
+ */
+
+/**
+ * @param {string} url
+ * @param {{ timeout?: number, headers?: object }} [options]
+ * @returns {Promise<{ ok: boolean, status: number, json: any, headers: Headers }|null>}
+ */
+async function fetchJson(url, { timeout = 8000, headers = {} } = {}) {
+  if (typeof fetch !== 'function') return null;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: 'application/json', ...headers },
+      signal: controller.signal,
+      redirect: 'follow',
+    });
+    let json = null;
+    try {
+      json = await res.json();
+    } catch {
+      json = null;
+    }
+    return { ok: res.ok, status: res.status, json, headers: res.headers };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Runs an async mapper over items with bounded concurrency.
+ * @template T, R
+ * @param {T[]} items
+ * @param {(item: T, index: number) => Promise<R>} mapper
+ * @param {number} concurrency
+ * @returns {Promise<R[]>}
+ */
+async function mapLimit(items, mapper, concurrency = 8) {
+  const results = new Array(items.length);
+  let cursor = 0;
+
+  const workers = new Array(Math.min(concurrency, items.length)).fill(0).map(async () => {
+    while (cursor < items.length) {
+      const index = cursor++;
+      results[index] = await mapper(items[index], index);
+    }
+  });
+
+  await Promise.all(workers);
+  return results;
+}
+
+module.exports = { fetchJson, mapLimit };

package/src/utils/logger.js

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * Minimal ANSI logger with no external dependencies.
+ * Colors are automatically disabled when output is not a TTY,
+ * when NO_COLOR is set, or when --no-color was requested.
+ */
+
+const SUPPORTS_COLOR =
+  process.stdout.isTTY &&
+  !process.env.NO_COLOR &&
+  process.env.TERM !== 'dumb';
+
+let colorEnabled = SUPPORTS_COLOR;
+
+const CODES = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+function paint(code, text) {
+  if (!colorEnabled) return text;
+  return `${CODES[code]}${text}${CODES.reset}`;
+}
+
+const color = {
+  bold: (t) => paint('bold', t),
+  dim: (t) => paint('dim', t),
+  red: (t) => paint('red', t),
+  green: (t) => paint('green', t),
+  yellow: (t) => paint('yellow', t),
+  blue: (t) => paint('blue', t),
+  magenta: (t) => paint('magenta', t),
+  cyan: (t) => paint('cyan', t),
+  gray: (t) => paint('gray', t),
+};
+
+const SYMBOLS = {
+  ok: () => color.green('✔'),
+  fail: () => color.red('✖'),
+  warn: () => color.yellow('⚠'),
+  info: () => color.blue('ℹ'),
+  bullet: () => color.gray('•'),
+};
+
+const logger = {
+  setColor(enabled) {
+    colorEnabled = Boolean(enabled) && SUPPORTS_COLOR;
+  },
+  log(...args) {
+    process.stdout.write(args.join(' ') + '\n');
+  },
+  raw(text) {
+    process.stdout.write(text);
+  },
+  info(msg) {
+    this.log(`${SYMBOLS.info()} ${msg}`);
+  },
+  success(msg) {
+    this.log(`${SYMBOLS.ok()} ${msg}`);
+  },
+  warn(msg) {
+    this.log(`${SYMBOLS.warn()} ${color.yellow(msg)}`);
+  },
+  error(msg) {
+    process.stderr.write(`${SYMBOLS.fail()} ${color.red(msg)}\n`);
+  },
+  heading(msg) {
+    this.log('');
+    this.log(color.bold(color.cyan(msg)));
+  },
+  detail(msg) {
+    this.log(`  ${color.gray(msg)}`);
+  },
+};
+
+module.exports = { logger, color, SYMBOLS };