@skillsmith/core 0.10.0 → 0.11.0

package/dist/src/logging/logger.d.ts

@@ -0,0 +1,71 @@
+/**
+ * SMI-5615: Shared structured JSON-line logger.
+ *
+ * Generalized from the dead `packages/mcp-server/src/logger.ts` (SMI-883
+ * redaction) into a surface-agnostic module usable by the MCP server, CLI,
+ * and VS Code extension independently — `createLogger(surface)` is a
+ * factory, not a singleton, so each host process can mint its own logger
+ * (optionally stamped with its own package version) while still writing to
+ * per-surface files that are safe to share across processes for the same
+ * surface (see `rotation.ts`).
+ *
+ * Call-site invariants (see
+ * docs/internal/implementation/production-error-logging.md §1 and the
+ * Shared-State / Coordination Audit table, F2/F3):
+ *
+ *   - `getCorrelationId()` is read SYNCHRONOUSLY at the call site, inside
+ *     `buildRecord`, never inside an async flush/rotation callback (F3) — a
+ *     deferred read could observe a different call's (or no) correlation ID
+ *     once the originating call's `AsyncLocalStorage` scope has unwound.
+ *   - The full JSON-line record (including the synchronously-read
+ *     correlation ID and synchronously-applied redaction) is built and
+ *     `JSON.stringify`'d BEFORE handing the string off to `rotation.ts`'s
+ *     serialized per-surface writer (F2) — only the actual disk write may
+ *     complete asynchronously; by the time it starts, the record content is
+ *     already frozen.
+ *   - Logger calls never throw. Any failure while assembling or persisting a
+ *     record falls back to `console.error`/`console.warn` (matching level,
+ *     with `info`/`debug` also routed to `console.error`) rather than being
+ *     fully silent — stderr remains the safety net of last resort. This
+ *     differs from the old logger's "silently fail" comment intent, which is
+ *     no longer acceptable once this is the only durable failure signal.
+ *   - `warn`/`error` ALWAYS mirror to `console.warn`/`console.error`,
+ *     synchronously, regardless of whether the disk write succeeds — this is
+ *     NOT a failure-only fallback for those two levels (only `info`/`debug`
+ *     use console purely as a write-failure fallback). This is what makes
+ *     `logger.error`/`logger.warn` a safe drop-in replacement for existing
+ *     `console.error`/`console.warn` call sites in the MCP server and CLI —
+ *     the caller-visible terminal/stderr output stays identical to today,
+ *     with redacted disk persistence added on top rather than instead of it.
+ */
+import type { LogDetails, Surface } from './types.js';
+export interface CreateLoggerOptions {
+    /**
+     * Package/CLI version stamped on every record from this logger instance.
+     * Defaults to `'unknown'` — pass each host package's own `version` (e.g.
+     * from its own `package.json`) at its entrypoint for an accurate value.
+     */
+    version?: string;
+}
+export interface Logger {
+    info(message: string, details?: LogDetails): void;
+    warn(message: string, details?: LogDetails): void;
+    error(message: string, details?: LogDetails): void;
+    debug(message: string, details?: LogDetails): void;
+}
+/**
+ * Creates a logger bound to `surface`. Independent instances for different
+ * surfaces (or the same surface with different `version` stamps) are safe to
+ * create concurrently — they only share state at the `rotation.ts` layer,
+ * which is itself safe for concurrent writers to the same surface (F2).
+ */
+export declare function createLogger(surface: Surface, options?: CreateLoggerOptions): Logger;
+/**
+ * Memoized per-surface logger created with default options
+ * (`version: 'unknown'`). Prefer calling `createLogger(surface, { version })`
+ * once at each package's entrypoint so records carry that package's real
+ * version; `getLogger` is a convenience for call sites that don't need a
+ * custom version stamp and want a single shared instance per surface.
+ */
+export declare function getLogger(surface: Surface): Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/logging/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/logging/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAuB,OAAO,EAAE,MAAM,YAAY,CAAA;AA2L1E,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IACjD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IACjD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;IAClD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;CACnD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE,mBAAwB,GAAG,MAAM,CA0BxF;AAID;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAOlD"}

package/dist/src/logging/logger.js

@@ -0,0 +1,264 @@
+/**
+ * SMI-5615: Shared structured JSON-line logger.
+ *
+ * Generalized from the dead `packages/mcp-server/src/logger.ts` (SMI-883
+ * redaction) into a surface-agnostic module usable by the MCP server, CLI,
+ * and VS Code extension independently — `createLogger(surface)` is a
+ * factory, not a singleton, so each host process can mint its own logger
+ * (optionally stamped with its own package version) while still writing to
+ * per-surface files that are safe to share across processes for the same
+ * surface (see `rotation.ts`).
+ *
+ * Call-site invariants (see
+ * docs/internal/implementation/production-error-logging.md §1 and the
+ * Shared-State / Coordination Audit table, F2/F3):
+ *
+ *   - `getCorrelationId()` is read SYNCHRONOUSLY at the call site, inside
+ *     `buildRecord`, never inside an async flush/rotation callback (F3) — a
+ *     deferred read could observe a different call's (or no) correlation ID
+ *     once the originating call's `AsyncLocalStorage` scope has unwound.
+ *   - The full JSON-line record (including the synchronously-read
+ *     correlation ID and synchronously-applied redaction) is built and
+ *     `JSON.stringify`'d BEFORE handing the string off to `rotation.ts`'s
+ *     serialized per-surface writer (F2) — only the actual disk write may
+ *     complete asynchronously; by the time it starts, the record content is
+ *     already frozen.
+ *   - Logger calls never throw. Any failure while assembling or persisting a
+ *     record falls back to `console.error`/`console.warn` (matching level,
+ *     with `info`/`debug` also routed to `console.error`) rather than being
+ *     fully silent — stderr remains the safety net of last resort. This
+ *     differs from the old logger's "silently fail" comment intent, which is
+ *     no longer acceptable once this is the only durable failure signal.
+ *   - `warn`/`error` ALWAYS mirror to `console.warn`/`console.error`,
+ *     synchronously, regardless of whether the disk write succeeds — this is
+ *     NOT a failure-only fallback for those two levels (only `info`/`debug`
+ *     use console purely as a write-failure fallback). This is what makes
+ *     `logger.error`/`logger.warn` a safe drop-in replacement for existing
+ *     `console.error`/`console.warn` call sites in the MCP server and CLI —
+ *     the caller-visible terminal/stderr output stays identical to today,
+ *     with redacted disk persistence added on top rather than instead of it.
+ */
+import { getCorrelationId } from './context.js';
+import { redactSensitiveData, redactSensitiveObject, stripAnsi } from './redact.js';
+import { writeLogLine } from './rotation.js';
+const LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+const MAX_STACK_FRAMES = 20;
+/**
+ * Accepts `'1'`/`'true'` (case-insensitive) — matches the existing
+ * `SKILLSMITH_<FEATURE>_DISABLE` convention, e.g.
+ * `isInventorySyncDisabledLocally()` at
+ * `packages/core/src/config/device-identity.ts:124`
+ * (`SKILLSMITH_INVENTORY_DISABLE`).
+ */
+function isLoggingDisabled() {
+    const val = process.env.SKILLSMITH_ERROR_LOG_DISABLE;
+    if (!val)
+        return false;
+    return val === '1' || val.toLowerCase() === 'true';
+}
+function configuredLevel() {
+    const raw = process.env.SKILLSMITH_LOG_LEVEL?.toLowerCase();
+    if (raw === 'debug' || raw === 'info' || raw === 'warn' || raw === 'error') {
+        return raw;
+    }
+    return 'warn';
+}
+function isLevelEnabled(level) {
+    return LEVEL_ORDER[level] >= LEVEL_ORDER[configuredLevel()];
+}
+/**
+ * Fallback console channel for a level. `warn` mirrors to `console.warn`
+ * (stderr); everything else — including `info`/`debug`, which have no
+ * dedicated stderr-only console method — falls back to `console.error`
+ * (stderr) so a failure never lands on stdout. MCP servers must keep stdout
+ * clean for the stdio JSON-RPC transport; `console.log`/`console.info` write
+ * to stdout and would corrupt it.
+ *
+ * Always redacts `message` before printing (Mode-B diff-audit NEW-1): this is
+ * the last-resort channel when the redacted disk record couldn't be built or
+ * written, so it must independently uphold the same SMI-883 guarantee — never
+ * pass the raw, un-redacted message straight to `console.*`.
+ */
+function consoleFallback(level, message) {
+    const redacted = redactSensitiveData(message);
+    if (level === 'warn') {
+        console.warn(redacted);
+    }
+    else {
+        console.error(redacted);
+    }
+}
+// SMI-5615 Mode-B (Wave 2 pass): ANSI stripped BEFORE redaction on every
+// disk-bound field — see `stripAnsi`'s doc comment in `redact.ts` for why
+// (embedded chalk escape codes are log noise AND can defeat the redaction
+// regex's leading word-boundary check).
+function redactForDisk(text) {
+    return redactSensitiveData(stripAnsi(text));
+}
+function normalizeError(err) {
+    if (err instanceof Error) {
+        const frames = err.stack
+            ? err.stack.split('\n').slice(0, MAX_STACK_FRAMES).join('\n')
+            : undefined;
+        return {
+            name: err.name,
+            message: redactForDisk(err.message),
+            stack: frames ? redactForDisk(frames) : undefined,
+        };
+    }
+    if (typeof err === 'string') {
+        return { name: 'Error', message: redactForDisk(err) };
+    }
+    if (err && typeof err === 'object') {
+        const asRecord = err;
+        const name = typeof asRecord.name === 'string' ? asRecord.name : 'Error';
+        const message = typeof asRecord.message === 'string'
+            ? asRecord.message
+            : safeStringify(redactSensitiveObject(asRecord));
+        return { name, message: redactForDisk(message) };
+    }
+    return { name: 'Error', message: redactForDisk(String(err)) };
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return '[unserializable value]';
+    }
+}
+/**
+ * Builds the complete, already-redacted `LogRecord` synchronously — this is
+ * the F2/F3 boundary: everything below runs on the calling stack, before any
+ * async write is even scheduled.
+ */
+function buildRecord(surface, level, version, message, details) {
+    // F3: correlation ID read synchronously, at the call site — never deferred.
+    const correlationId = getCorrelationId();
+    const { event, err, toolOrCommand, skillId, ...rest } = details ?? {};
+    const record = {
+        ts: new Date().toISOString(),
+        level,
+        surface,
+        event: typeof event === 'string' && event.length > 0 ? event : level,
+        msg: redactForDisk(message),
+        version,
+        pid: process.pid,
+    };
+    if (correlationId)
+        record.correlationId = correlationId;
+    if (typeof toolOrCommand === 'string')
+        record.toolOrCommand = toolOrCommand;
+    if (typeof skillId === 'string')
+        record.skillId = skillId;
+    if (err !== undefined)
+        record.err = normalizeError(err);
+    if (Object.keys(rest).length > 0) {
+        record.details = redactSensitiveObject(rest);
+    }
+    return record;
+}
+/**
+ * Hands the fully-built record off to `rotation.ts`, AND mirrors `warn`/
+ * `error` to console UNCONDITIONALLY (not only on a write failure) — per
+ * plan §1: "the logger writes to disk AND still emits to stderr for warn/
+ * error". This is the mechanism that lets `packages/mcp-server/src/index.ts`
+ * and `packages/cli/src` replace their scattered `console.error`/`warn`
+ * calls with `logger.error`/`warn` as a drop-in swap: the caller-visible
+ * terminal/stderr output must be identical to today, with disk persistence
+ * added on top — not replaced by it. `info`/`debug` are disk-only by design
+ * (routine/diagnostic detail, not something every caller needs to see live);
+ * they still reach console as a write-failure fallback like before, via the
+ * `catch` paths below, so a failure is never fully silent at any level.
+ */
+function persistRecord(surface, level, message, record) {
+    if (level === 'warn' || level === 'error') {
+        consoleFallback(level, message);
+    }
+    try {
+        const line = safeStringifyRecord(record, message);
+        writeLogLine(surface, line).catch(() => {
+            if (level !== 'warn' && level !== 'error')
+                consoleFallback(level, message);
+        });
+    }
+    catch {
+        // Synchronous failure calling into rotation.ts (should be effectively
+        // unreachable — `writeLogLine` itself only throws via its returned
+        // Promise — but the invariant is "never throws", full stop).
+        if (level !== 'warn' && level !== 'error')
+            consoleFallback(level, message);
+    }
+}
+function safeStringifyRecord(record, fallbackMessage) {
+    try {
+        return JSON.stringify(record);
+    }
+    catch {
+        // Circular reference or similar inside `details`/`err` — degrade to a
+        // minimal, definitely-serializable record rather than losing the
+        // message and metadata entirely.
+        const { details: _details, err: _err, ...safe } = record;
+        return JSON.stringify({
+            ...safe,
+            msg: `${redactForDisk(fallbackMessage)} [unserializable details/err omitted]`,
+        });
+    }
+}
+/**
+ * Creates a logger bound to `surface`. Independent instances for different
+ * surfaces (or the same surface with different `version` stamps) are safe to
+ * create concurrently — they only share state at the `rotation.ts` layer,
+ * which is itself safe for concurrent writers to the same surface (F2).
+ */
+export function createLogger(surface, options = {}) {
+    const version = options.version ?? 'unknown';
+    function log(level, message, details) {
+        try {
+            if (isLoggingDisabled())
+                return;
+            if (!isLevelEnabled(level))
+                return;
+            const record = buildRecord(surface, level, version, message, details);
+            persistRecord(surface, level, message, record);
+        }
+        catch {
+            // Absolute last resort — never let a logging call throw into the
+            // caller, regardless of what went wrong above.
+            try {
+                consoleFallback(level, message);
+            }
+            catch {
+                // Truly nothing left to do.
+            }
+        }
+    }
+    return {
+        info: (message, details) => log('info', message, details),
+        warn: (message, details) => log('warn', message, details),
+        error: (message, details) => log('error', message, details),
+        debug: (message, details) => log('debug', message, details),
+    };
+}
+const memoizedLoggers = new Map();
+/**
+ * Memoized per-surface logger created with default options
+ * (`version: 'unknown'`). Prefer calling `createLogger(surface, { version })`
+ * once at each package's entrypoint so records carry that package's real
+ * version; `getLogger` is a convenience for call sites that don't need a
+ * custom version stamp and want a single shared instance per surface.
+ */
+export function getLogger(surface) {
+    let logger = memoizedLoggers.get(surface);
+    if (!logger) {
+        logger = createLogger(surface);
+        memoizedLoggers.set(surface, logger);
+    }
+    return logger;
+}
+//# sourceMappingURL=logger.js.map

package/dist/src/logging/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../../src/logging/logger.ts"],"names":[],"mappings":"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"}

package/dist/src/logging/logger.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SMI-5615: Tests for the shared `logger.ts` factory — crash-proofing,
+ * `SKILLSMITH_ERROR_LOG_DISABLE`, `SKILLSMITH_LOG_LEVEL` filtering,
+ * redaction-on-disk, and the correlation-ID call-site invariant (F3). All
+ * tests point `SKILLSMITH_LOG_DIR` at a temp directory — never the real
+ * `~/.skillsmith/logs/`.
+ */
+export {};
+//# sourceMappingURL=logger.test.d.ts.map

package/dist/src/logging/logger.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../../../src/logging/logger.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}