@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/utils/log.js

@@ -0,0 +1,57 @@
+/**
+ * File logger — writes structured logs to .unerr/logs/ in the repo root.
+ *
+ * Each setup run creates a timestamped log file. All API calls, responses,
+ * and errors are recorded. On error, the CLI prints the log file path.
+ *
+ * Built on consola — routes all output to file, never to stdout.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+let logFilePath = null;
+function ensureLogDir(cwd) {
+    const logsDir = join(cwd, ".unerr", "logs");
+    mkdirSync(logsDir, { recursive: true });
+    return logsDir;
+}
+function timestamp() {
+    return new Date().toISOString();
+}
+function datestamp() {
+    return new Date().toISOString().slice(0, 10);
+}
+export function initLogFile(cwd) {
+    const logsDir = ensureLogDir(cwd);
+    logFilePath = join(logsDir, `setup-${datestamp()}.log`);
+    write("info", "=== unerr setup started ===");
+    write("info", `cwd: ${cwd}`);
+    write("info", `node: ${process.version}`);
+    write("info", `platform: ${process.platform} ${process.arch}`);
+    return logFilePath;
+}
+function write(level, message, data) {
+    if (!logFilePath)
+        return;
+    const line = data
+        ? `[${timestamp()}] [${level}] ${message} ${JSON.stringify(data)}`
+        : `[${timestamp()}] [${level}] ${message}`;
+    try {
+        appendFileSync(logFilePath, `${line}\n`);
+    }
+    catch {
+        /* best effort — never crash on logging failure */
+    }
+}
+export function logInfo(message, data) {
+    write("info", message, data);
+}
+export function logError(message, data) {
+    write("error", message, data);
+}
+export function logApi(method, url, status, body) {
+    const statusStr = status !== undefined ? ` → ${status}` : "";
+    write("api", `${method} ${url}${statusStr}`, body);
+}
+export function getLogFilePath() {
+    return logFilePath;
+}

package/dist/utils/logger.js

@@ -0,0 +1,35 @@
+/**
+ * Centralized Logger — consola-based, stderr-only.
+ *
+ * CRITICAL INVARIANT: stdout is reserved for MCP JSON-RPC protocol.
+ * Every log call routes to stderr. This is enforced at construction time
+ * by setting both stdout and stderr streams to process.stderr.
+ *
+ * Design notes (temporal intelligence foundation):
+ *   - Structured event emission supports future episodic memory capture.
+ *   - Module-scoped child loggers enable per-subsystem log routing.
+ *   - Log levels respect UNERR_LOG_LEVEL env var (0=silent, 3=info, 4=debug, 5=trace).
+ */
+import { createConsola } from "consola";
+const resolveLevel = () => {
+    const env = process.env.UNERR_LOG_LEVEL;
+    if (env !== undefined) {
+        const parsed = Number(env);
+        return Number.isFinite(parsed) ? parsed : 3;
+    }
+    return process.env.NODE_ENV === "test" ? 0 : 3;
+};
+export const logger = createConsola({
+    stdout: process.stderr,
+    stderr: process.stderr,
+    level: resolveLevel(),
+    defaults: { tag: "unerr" },
+    formatOptions: {
+        date: false,
+        colors: process.env.NO_COLOR === undefined,
+        compact: true,
+    },
+});
+export function createModuleLogger(module) {
+    return logger.withTag(module);
+}

package/dist/utils/mcp-content-json.js

@@ -0,0 +1,8 @@
+/**
+ * Layer 6 — Sprint FE-A (§43): MCP tool `content[].text` payloads use compact JSON only.
+ * Pretty-printed JSON (`JSON.stringify(v, null, 2)`) inflates token count by ~15–25%
+ * on structural whitespace (`LAYER_6_FORMAT_ENCODING.md`).
+ */
+export function stringifyMcpToolJson(value) {
+    return JSON.stringify(value);
+}

package/dist/utils/session-logger.js

@@ -0,0 +1,154 @@
+/**
+ * Session Logger — consola-based structured logging to .unerr/logs/.
+ *
+ * All debug and diagnostic data goes here, never to the terminal.
+ * Terminal shows only user-facing output (ora spinners, styled stats).
+ *
+ * Format: NDJSON — one JSON object per line.
+ * Rotation: max 10 files, max 10MB each.
+ * Retention: 30 days (older files auto-deleted on boot).
+ *
+ * Temporal intelligence note: session log entries form the episodic memory
+ * tier (fast decay, power-law half-life ~3 days). The consolidation daemon
+ * compresses these into semantic facts during idle phases.
+ */
+import { randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
+import { join } from "node:path";
+import { createConsola } from "consola";
+const SESSION_ID = randomUUID();
+const RETENTION_DAYS = 30;
+const MAX_FILES = 10;
+function formatTimestamp() {
+    const d = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+function cleanupOldLogs(logsDir) {
+    if (!existsSync(logsDir))
+        return;
+    try {
+        const files = readdirSync(logsDir)
+            .filter((f) => f.startsWith("session-") && f.endsWith(".log"))
+            .map((f) => {
+            const fullPath = join(logsDir, f);
+            const stat = statSync(fullPath);
+            return {
+                name: f,
+                path: fullPath,
+                mtimeMs: stat.mtimeMs,
+            };
+        })
+            .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        const cutoff = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1000;
+        for (const file of files) {
+            if (file.mtimeMs < cutoff) {
+                try {
+                    unlinkSync(file.path);
+                }
+                catch {
+                    /* best effort */
+                }
+            }
+        }
+        const remaining = files.filter((f) => existsSync(f.path));
+        if (remaining.length > MAX_FILES) {
+            for (const file of remaining.slice(MAX_FILES)) {
+                try {
+                    unlinkSync(file.path);
+                }
+                catch {
+                    /* best effort */
+                }
+            }
+        }
+    }
+    catch {
+        /* never crash on log cleanup failure */
+    }
+}
+let _logger = null;
+let _logFilePath = null;
+/**
+ * Initialize the session logger. Call once at boot.
+ * Returns the consola logger instance. Subsequent calls return the same instance.
+ */
+export function initSessionLogger(opts = {}) {
+    if (_logger)
+        return _logger;
+    const cwd = opts.cwd ?? process.cwd();
+    const logsDir = join(cwd, ".unerr", "logs");
+    mkdirSync(logsDir, { recursive: true });
+    cleanupOldLogs(logsDir);
+    const timestamp = formatTimestamp();
+    _logFilePath = join(logsDir, `session-${timestamp}.log`);
+    const levelNum = opts.level !== undefined ? Number(opts.level) : undefined;
+    const envLevel = process.env.UNERR_LOG_LEVEL;
+    const resolvedLevel = levelNum ?? (envLevel ? Number(envLevel) : 3);
+    _logger = createConsola({
+        level: resolvedLevel,
+        stdout: process.stderr,
+        stderr: process.stderr,
+        reporters: [
+            {
+                log: (logObj) => {
+                    if (!_logFilePath)
+                        return;
+                    try {
+                        const entry = {
+                            time: new Date().toISOString(),
+                            level: logObj.type,
+                            session_id: SESSION_ID,
+                            tag: logObj.tag,
+                            msg: logObj.args
+                                .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
+                                .join(" "),
+                        };
+                        appendFileSync(_logFilePath, `${JSON.stringify(entry)}\n`);
+                    }
+                    catch {
+                        /* best effort */
+                    }
+                },
+            },
+        ],
+    });
+    _logger.info({
+        module: "logger",
+        msg: "Session started",
+        data: { cwd, level: resolvedLevel },
+    });
+    return _logger;
+}
+/**
+ * Get the current session logger. Returns a silent logger if not initialized.
+ */
+export function getSessionLogger() {
+    if (_logger)
+        return _logger;
+    return createConsola({ level: -999 });
+}
+/**
+ * Create a child logger scoped to a specific module.
+ */
+export function createSessionModuleLogger(module) {
+    return getSessionLogger().withTag(module);
+}
+/**
+ * Get the current session log file path.
+ */
+export function getSessionLogPath() {
+    return _logFilePath;
+}
+/**
+ * Get the current session ID.
+ */
+export function getSessionId() {
+    return SESSION_ID;
+}
+/**
+ * Flush the logger (for graceful shutdown). No-op for consola (writes are sync).
+ */
+export function flushSessionLogger() {
+    /* consola file writes are synchronous via appendFileSync — no flush needed */
+}