@happyvertical/logger 0.74.8

package/AGENT.md

@@ -0,0 +1,33 @@
+# @happyvertical/logger
+
+<!-- BEGIN AGENT:GENERATED -->
+## Purpose
+Structured logging for HAVE SDK with signal adapter
+
+## Package Map
+- Package: `@happyvertical/logger`
+- Hierarchy path: `@happyvertical/sdk > packages > logger`
+- Workspace position: `18 of 30` local packages
+- Internal dependencies: `@happyvertical/utils`
+- Internal dependents: `@happyvertical/comfyui`, `@happyvertical/email`, `@happyvertical/encryption`, `@happyvertical/messages`, `@happyvertical/social`, `@happyvertical/video`
+- Knowledge graph files: `AGENT.md`, `metadata.json`, `ecosystem-manifest.json`
+
+## Build & Test
+```bash
+pnpm --filter @happyvertical/logger build
+pnpm --filter @happyvertical/logger test
+pnpm --filter @happyvertical/logger typecheck
+```
+
+## Agent Correction Loops
+- If module resolution or export errors mention a workspace dependency, build the dependency first (`pnpm --filter @happyvertical/utils build`) and then rerun `pnpm --filter @happyvertical/logger build`.
+- If you hit type-only regressions, run `pnpm --filter @happyvertical/logger typecheck` before rerunning the package build or tests to isolate the failing surface.
+- If failures span multiple packages or Turborepo ordering looks wrong, run `pnpm build` and `pnpm typecheck` from the repo root before retrying package-scoped commands.
+
+## Ecosystem Relationships
+- Provides: Structured logging for HAVE SDK with signal adapter
+- Implements: none
+- Requires: @happyvertical/utils, @sentry/node
+- Stability: stable (Primary package surface is described as implemented and production-oriented.)
+<!-- END AGENT:GENERATED -->
+

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright <2025> <Happy Vertical Corporation>
+
+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,135 @@
+# @happyvertical/logger
+
+Structured logging for HAVE SDK with signal adapter integration and optional Sentry error tracking. Provides a `Logger` interface with four severity levels, a console implementation with level filtering, and adapters that convert SMRT framework signals into log entries or Sentry breadcrumbs/exceptions.
+
+## Installation
+
+```bash
+pnpm add @happyvertical/logger
+
+# Optional: for Sentry integration
+pnpm add @sentry/node
+```
+
+Depends on `@happyvertical/utils`. Optional peer dependency on `@sentry/node` (for the `/sentry` subpath).
+
+## Basic Usage
+
+```typescript
+import { createLogger } from '@happyvertical/logger';
+
+// Console logger with default 'info' level
+const logger = createLogger(true);
+
+logger.info('Application started');
+logger.debug('Verbose detail'); // Not output (below 'info')
+logger.warn('High memory usage', { memoryMB: 512 });
+logger.error('Connection failed', { host: 'localhost', port: 5432 });
+
+// Configure a specific level
+const debugLogger = createLogger({ level: 'debug' });
+
+// No-op logger — all calls discarded, zero overhead
+const silent = createLogger(false);
+```
+
+### Environment Variable
+
+Set `HAVE_LOGGER_LEVEL` to `debug`, `info`, `warn`, or `error`. Applies when using `createLogger(true)` or `createLogger({})`. Explicit config takes precedence:
+
+```typescript
+process.env.HAVE_LOGGER_LEVEL = 'debug';
+const logger = createLogger(true); // uses 'debug' from env
+
+const explicit = createLogger({ level: 'warn' }); // uses 'warn', ignores env
+```
+
+## Log Levels
+
+`debug < info < warn < error` — messages below the configured threshold are discarded.
+
+```typescript
+const logger = createLogger({ level: 'warn' });
+logger.debug('ignored');  // not output
+logger.info('ignored');   // not output
+logger.warn('output');    // output
+logger.error('output');   // output
+```
+
+Output format: `[LEVEL] message {"key":"value"}`
+
+## Signal Adapter
+
+`LoggerAdapter` converts SMRT framework signals into structured log entries:
+
+```typescript
+import { createLogger, LoggerAdapter } from '@happyvertical/logger';
+
+const logger = createLogger({ level: 'info' });
+const adapter = new LoggerAdapter(logger);
+// Register adapter with a signal bus to log operations automatically
+```
+
+Signal type mapping: `start` → debug, `step` → debug, `end` → info, `error` → error.
+
+## Sentry Adapter
+
+The `/sentry` subpath routes signals to Sentry/GlitchTip. Requires `@sentry/node` as a peer dependency.
+
+```typescript
+import { createSentryAdapter } from '@happyvertical/logger/sentry';
+
+const adapter = createSentryAdapter({ category: 'myapp' });
+// Register adapter with a signal bus
+
+// Error signals → Sentry.captureException with scope tags
+// Non-error signals → Sentry.addBreadcrumb for debugging trail
+```
+
+## API Overview
+
+### Factory
+
+| Function | Description |
+|----------|-------------|
+| `createLogger(config)` | Returns a `Logger` — `ConsoleLogger` when enabled, no-op when `false` |
+| `createSentryAdapter(config?)` | Returns a `SentryAdapter` (from `/sentry` subpath) |
+
+### Classes
+
+| Class | Description |
+|-------|-------------|
+| `ConsoleLogger` | Logger implementation with level filtering, writes to `console.*` |
+| `LoggerAdapter` | Signal adapter that converts signals to structured log messages |
+| `SentryAdapter` | Signal adapter that routes errors to Sentry and adds breadcrumbs |
+
+### Types
+
+| Type | Description |
+|------|-------------|
+| `Logger` | Interface with `debug`, `info`, `warn`, `error` methods |
+| `LogLevel` | `'debug' \| 'info' \| 'warn' \| 'error'` |
+| `LoggerConfig` | `boolean \| { level?: LogLevel }` |
+| `Signal` | Signal event from operation execution |
+| `SignalAdapter` | Interface for handling signals |
+| `SignalType` | `'start' \| 'step' \| 'end' \| 'error'` |
+| `SentryAdapterConfig` | `{ category?: string }` |
+
+### Custom Logger
+
+Implement the `Logger` interface for custom backends:
+
+```typescript
+import type { Logger } from '@happyvertical/logger';
+
+class MyLogger implements Logger {
+  debug(message: string, context?: Record<string, unknown>): void { /* ... */ }
+  info(message: string, context?: Record<string, unknown>): void { /* ... */ }
+  warn(message: string, context?: Record<string, unknown>): void { /* ... */ }
+  error(message: string, context?: Record<string, unknown>): void { /* ... */ }
+}
+```
+
+## License
+
+MIT

package/dist/adapter.d.ts

@@ -0,0 +1,30 @@
+import { Logger } from './logger.js';
+import { Signal, SignalAdapter } from './signal-types.js';
+/**
+ * Logger Adapter - Converts signals to structured log messages
+ *
+ * Transforms signals from the SMRT framework into structured log entries.
+ * Each signal type is mapped to an appropriate log level:
+ * - start → debug
+ * - step → debug
+ * - end → info
+ * - error → error
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConsoleLogger('info');
+ * const adapter = new LoggerAdapter(logger);
+ * signalBus.register(adapter);
+ * ```
+ */
+export declare class LoggerAdapter implements SignalAdapter {
+    private logger;
+    constructor(logger: Logger);
+    /**
+     * Handle a signal and log appropriately
+     *
+     * @param signal - Signal to log
+     */
+    handle(signal: Signal): Promise<void>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,aAAc,YAAW,aAAa;IACrC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;OAIG;IACG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA4D5C"}

package/dist/cli/claude-context.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=claude-context.d.ts.map

package/dist/cli/claude-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-context.d.ts","sourceRoot":"","sources":["../../src/cli/claude-context.ts"],"names":[],"mappings":""}

package/dist/cli/claude-context.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, copyFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const Dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = join(Dirname, "../..");
+const targetDir = join(process.cwd(), ".claude");
+if (!existsSync(targetDir)) {
+  mkdirSync(targetDir, { recursive: true });
+}
+const pkgName = "logger";
+const agentMdSrc = existsSync(join(pkgRoot, "AGENT.md")) ? join(pkgRoot, "AGENT.md") : join(pkgRoot, "CLAUDE.md");
+const metaSrc = existsSync(join(pkgRoot, "metadata.json")) ? join(pkgRoot, "metadata.json") : join(pkgRoot, ".claude-meta.json");
+if (existsSync(agentMdSrc)) {
+  copyFileSync(agentMdSrc, join(targetDir, `have-${pkgName}.md`));
+}
+if (existsSync(metaSrc)) {
+  copyFileSync(metaSrc, join(targetDir, `have-${pkgName}.meta.json`));
+}
+console.log(`✓ Installed @happyvertical/${pkgName} context to .claude/`);
+//# sourceMappingURL=claude-context.js.map

package/dist/cli/claude-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-context.js","sources":["../../src/cli/claude-context.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * CLI script to install agent context for @happyvertical/logger\n * Run the published context installer binary for this package.\n */\nimport { copyFileSync, existsSync, mkdirSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nconst Dirname = dirname(fileURLToPath(import.meta.url));\nconst pkgRoot = join(Dirname, '../..');\nconst targetDir = join(process.cwd(), '.claude');\n\nif (!existsSync(targetDir)) {\n  mkdirSync(targetDir, { recursive: true });\n}\n\nconst pkgName = 'logger';\nconst agentMdSrc = existsSync(join(pkgRoot, 'AGENT.md'))\n  ? join(pkgRoot, 'AGENT.md')\n  : join(pkgRoot, 'CLAUDE.md');\nconst metaSrc = existsSync(join(pkgRoot, 'metadata.json'))\n  ? join(pkgRoot, 'metadata.json')\n  : join(pkgRoot, '.claude-meta.json');\n\nif (existsSync(agentMdSrc)) {\n  copyFileSync(agentMdSrc, join(targetDir, `have-${pkgName}.md`));\n}\n\nif (existsSync(metaSrc)) {\n  copyFileSync(metaSrc, join(targetDir, `have-${pkgName}.meta.json`));\n}\n\nconsole.log(`✓ Installed @happyvertical/${pkgName} context to .claude/`);\n"],"names":[],"mappings":";;;;AASA,MAAM,UAAU,QAAQ,cAAc,YAAY,GAAG,CAAC;AACtD,MAAM,UAAU,KAAK,SAAS,OAAO;AACrC,MAAM,YAAY,KAAK,QAAQ,IAAA,GAAO,SAAS;AAE/C,IAAI,CAAC,WAAW,SAAS,GAAG;AAC1B,YAAU,WAAW,EAAE,WAAW,KAAA,CAAM;AAC1C;AAEA,MAAM,UAAU;AAChB,MAAM,aAAa,WAAW,KAAK,SAAS,UAAU,CAAC,IACnD,KAAK,SAAS,UAAU,IACxB,KAAK,SAAS,WAAW;AAC7B,MAAM,UAAU,WAAW,KAAK,SAAS,eAAe,CAAC,IACrD,KAAK,SAAS,eAAe,IAC7B,KAAK,SAAS,mBAAmB;AAErC,IAAI,WAAW,UAAU,GAAG;AAC1B,eAAa,YAAY,KAAK,WAAW,QAAQ,OAAO,KAAK,CAAC;AAChE;AAEA,IAAI,WAAW,OAAO,GAAG;AACvB,eAAa,SAAS,KAAK,WAAW,QAAQ,OAAO,YAAY,CAAC;AACpE;AAEA,QAAQ,IAAI,8BAA8B,OAAO,sBAAsB;"}

package/dist/console.d.ts

@@ -0,0 +1,39 @@
+import { Logger, LogLevel } from './logger.js';
+/**
+ * Console-based logger with level filtering
+ *
+ * Logs are written to console with appropriate severity levels.
+ * Messages are only output if they meet the configured log level threshold.
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConsoleLogger('info');
+ * logger.debug('Debug message');  // Not output (below 'info')
+ * logger.info('Info message');    // Output
+ * logger.error('Error message');  // Output
+ * ```
+ */
+export declare class ConsoleLogger implements Logger {
+    private level;
+    private static readonly LEVELS;
+    constructor(level?: LogLevel);
+    /**
+     * Check if a log level should be output
+     *
+     * @param level - Log level to check
+     * @returns True if level meets threshold
+     */
+    private shouldLog;
+    /**
+     * Format context for console output
+     *
+     * @param context - Structured metadata
+     * @returns Formatted context string
+     */
+    private formatContext;
+    debug(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+}
+//# sourceMappingURL=console.d.ts.map

package/dist/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../src/console.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAc,YAAW,MAAM;IAQ9B,OAAO,CAAC,KAAK;IAPzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAK5B;gBAEkB,KAAK,GAAE,QAAiB;IAE5C;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAMjB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAOrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAKhE"}

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import { Logger, LoggerConfig } from './logger.js';
+/**
+ * @happyvertical/logger - Structured logging for HAVE SDK
+ *
+ * Provides a structured logging interface with signal adapter integration.
+ * Supports configurable log levels and console output.
+ *
+ * @example
+ * ```typescript
+ * import { createLogger, LoggerAdapter } from '@happyvertical/logger';
+ *
+ * // Create logger
+ * const logger = createLogger({ level: 'info' });
+ * logger.info('Application started');
+ *
+ * // Integrate with signals
+ * const adapter = new LoggerAdapter(logger);
+ * ```
+ */
+export { LoggerAdapter } from './adapter.js';
+export { ConsoleLogger } from './console.js';
+export type { Logger, LoggerConfig, LogLevel } from './logger.js';
+export type { Signal, SignalAdapter, SignalType } from './signal-types.js';
+/**
+ * Create a logger from configuration
+ *
+ * Supports environment variable configuration via HAVE_LOGGER_LEVEL.
+ * User-provided options take precedence over environment variables.
+ *
+ * @param config - Logger configuration (boolean or object)
+ * @returns Configured logger instance
+ *
+ * @example
+ * ```typescript
+ * // Console logger with 'info' level (default)
+ * const logger1 = createLogger(true);
+ *
+ * // Console logger with level from HAVE_LOGGER_LEVEL env var
+ * process.env.HAVE_LOGGER_LEVEL = 'debug';
+ * const logger2 = createLogger(true); // Uses 'debug' from env
+ *
+ * // No-op logger (all log calls are discarded)
+ * const logger3 = createLogger(false);
+ *
+ * // Console logger with 'debug' level (overrides env)
+ * const logger4 = createLogger({ level: 'debug' });
+ *
+ * // Custom log level (user options take precedence)
+ * process.env.HAVE_LOGGER_LEVEL = 'info';
+ * const logger5 = createLogger({ level: 'warn' }); // Uses 'warn' not 'info'
+ * ```
+ */
+export declare function createLogger(config: LoggerConfig): Logger;
+/** @internal */
+export declare const PACKAGE_VERSION_INITIALIZED = true;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI3E,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAY,MAAM,aAAa,CAAC;AAyBlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CA2BzD;AAED,gBAAgB;AAChB,eAAO,MAAM,2BAA2B,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,155 @@
+import { loadEnvConfig } from "@happyvertical/utils";
+class LoggerAdapter {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Handle a signal and log appropriately
+   *
+   * @param signal - Signal to log
+   */
+  async handle(signal) {
+    const context = {
+      id: signal.id,
+      objectId: signal.objectId,
+      className: signal.className,
+      method: signal.method,
+      timestamp: signal.timestamp
+    };
+    if (signal.duration !== void 0) {
+      context.duration = signal.duration;
+    }
+    if (signal.metadata) {
+      context.metadata = signal.metadata;
+    }
+    switch (signal.type) {
+      case "start":
+        this.logger.debug(
+          `${signal.className}.${signal.method}() started`,
+          context
+        );
+        break;
+      case "step":
+        this.logger.debug(
+          `${signal.className}.${signal.method}() step: ${signal.step || "unknown"}`,
+          context
+        );
+        break;
+      case "end":
+        this.logger.info(
+          `${signal.className}.${signal.method}() completed in ${signal.duration}ms`,
+          {
+            ...context,
+            result: signal.result !== void 0 ? "present" : "none"
+          }
+        );
+        break;
+      case "error":
+        this.logger.error(
+          `${signal.className}.${signal.method}() failed: ${signal.error?.message || "Unknown error"}`,
+          {
+            ...context,
+            error: signal.error ? {
+              message: signal.error.message,
+              name: signal.error.name,
+              stack: signal.error.stack
+            } : void 0
+          }
+        );
+        break;
+    }
+  }
+}
+class ConsoleLogger {
+  constructor(level = "info") {
+    this.level = level;
+  }
+  static LEVELS = [
+    "debug",
+    "info",
+    "warn",
+    "error"
+  ];
+  /**
+   * Check if a log level should be output
+   *
+   * @param level - Log level to check
+   * @returns True if level meets threshold
+   */
+  shouldLog(level) {
+    const currentIndex = ConsoleLogger.LEVELS.indexOf(this.level);
+    const messageIndex = ConsoleLogger.LEVELS.indexOf(level);
+    return messageIndex >= currentIndex;
+  }
+  /**
+   * Format context for console output
+   *
+   * @param context - Structured metadata
+   * @returns Formatted context string
+   */
+  formatContext(context) {
+    if (!context || Object.keys(context).length === 0) {
+      return "";
+    }
+    return ` ${JSON.stringify(context)}`;
+  }
+  debug(message, context) {
+    if (this.shouldLog("debug")) {
+      console.debug(`[DEBUG] ${message}${this.formatContext(context)}`);
+    }
+  }
+  info(message, context) {
+    if (this.shouldLog("info")) {
+      console.info(`[INFO] ${message}${this.formatContext(context)}`);
+    }
+  }
+  warn(message, context) {
+    if (this.shouldLog("warn")) {
+      console.warn(`[WARN] ${message}${this.formatContext(context)}`);
+    }
+  }
+  error(message, context) {
+    if (this.shouldLog("error")) {
+      console.error(`[ERROR] ${message}${this.formatContext(context)}`);
+    }
+  }
+}
+class NoopLogger {
+  debug(_message, _context) {
+  }
+  info(_message, _context) {
+  }
+  warn(_message, _context) {
+  }
+  error(_message, _context) {
+  }
+}
+function createLogger(config) {
+  if (typeof config === "boolean") {
+    if (!config) {
+      return new NoopLogger();
+    }
+    const envConfig = loadEnvConfig(
+      {},
+      {
+        packageName: "logger",
+        schema: { level: "string" }
+      }
+    );
+    return new ConsoleLogger(envConfig.level || "info");
+  }
+  const mergedConfig = loadEnvConfig(config, {
+    packageName: "logger",
+    schema: { level: "string" }
+  });
+  const level = mergedConfig.level || "info";
+  return new ConsoleLogger(level);
+}
+const PACKAGE_VERSION_INITIALIZED = true;
+export {
+  ConsoleLogger,
+  LoggerAdapter,
+  PACKAGE_VERSION_INITIALIZED,
+  createLogger
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/adapter.ts","../src/console.ts","../src/index.ts"],"sourcesContent":["/**\n * Signal adapter for structured logging\n */\n\nimport type { Logger } from './logger.js';\nimport type { Signal, SignalAdapter } from './signal-types.js';\n\n/**\n * Logger Adapter - Converts signals to structured log messages\n *\n * Transforms signals from the SMRT framework into structured log entries.\n * Each signal type is mapped to an appropriate log level:\n * - start → debug\n * - step → debug\n * - end → info\n * - error → error\n *\n * @example\n * ```typescript\n * const logger = new ConsoleLogger('info');\n * const adapter = new LoggerAdapter(logger);\n * signalBus.register(adapter);\n * ```\n */\nexport class LoggerAdapter implements SignalAdapter {\n  constructor(private logger: Logger) {}\n\n  /**\n   * Handle a signal and log appropriately\n   *\n   * @param signal - Signal to log\n   */\n  async handle(signal: Signal): Promise<void> {\n    const context: Record<string, unknown> = {\n      id: signal.id,\n      objectId: signal.objectId,\n      className: signal.className,\n      method: signal.method,\n      timestamp: signal.timestamp,\n    };\n\n    // Add optional fields if present\n    if (signal.duration !== undefined) {\n      context.duration = signal.duration;\n    }\n\n    if (signal.metadata) {\n      context.metadata = signal.metadata;\n    }\n\n    switch (signal.type) {\n      case 'start':\n        this.logger.debug(\n          `${signal.className}.${signal.method}() started`,\n          context,\n        );\n        break;\n\n      case 'step':\n        this.logger.debug(\n          `${signal.className}.${signal.method}() step: ${signal.step || 'unknown'}`,\n          context,\n        );\n        break;\n\n      case 'end':\n        this.logger.info(\n          `${signal.className}.${signal.method}() completed in ${signal.duration}ms`,\n          {\n            ...context,\n            result: signal.result !== undefined ? 'present' : 'none',\n          },\n        );\n        break;\n\n      case 'error':\n        this.logger.error(\n          `${signal.className}.${signal.method}() failed: ${signal.error?.message || 'Unknown error'}`,\n          {\n            ...context,\n            error: signal.error\n              ? {\n                  message: signal.error.message,\n                  name: signal.error.name,\n                  stack: signal.error.stack,\n                }\n              : undefined,\n          },\n        );\n        break;\n    }\n  }\n}\n","/**\n * Console logger implementation with configurable log levels\n */\n\nimport type { Logger, LogLevel } from './logger.js';\n\n/**\n * Console-based logger with level filtering\n *\n * Logs are written to console with appropriate severity levels.\n * Messages are only output if they meet the configured log level threshold.\n *\n * @example\n * ```typescript\n * const logger = new ConsoleLogger('info');\n * logger.debug('Debug message');  // Not output (below 'info')\n * logger.info('Info message');    // Output\n * logger.error('Error message');  // Output\n * ```\n */\nexport class ConsoleLogger implements Logger {\n  private static readonly LEVELS: ReadonlyArray<LogLevel> = [\n    'debug',\n    'info',\n    'warn',\n    'error',\n  ];\n\n  constructor(private level: LogLevel = 'info') {}\n\n  /**\n   * Check if a log level should be output\n   *\n   * @param level - Log level to check\n   * @returns True if level meets threshold\n   */\n  private shouldLog(level: LogLevel): boolean {\n    const currentIndex = ConsoleLogger.LEVELS.indexOf(this.level);\n    const messageIndex = ConsoleLogger.LEVELS.indexOf(level);\n    return messageIndex >= currentIndex;\n  }\n\n  /**\n   * Format context for console output\n   *\n   * @param context - Structured metadata\n   * @returns Formatted context string\n   */\n  private formatContext(context?: Record<string, unknown>): string {\n    if (!context || Object.keys(context).length === 0) {\n      return '';\n    }\n    return ` ${JSON.stringify(context)}`;\n  }\n\n  debug(message: string, context?: Record<string, unknown>): void {\n    if (this.shouldLog('debug')) {\n      console.debug(`[DEBUG] ${message}${this.formatContext(context)}`);\n    }\n  }\n\n  info(message: string, context?: Record<string, unknown>): void {\n    if (this.shouldLog('info')) {\n      console.info(`[INFO] ${message}${this.formatContext(context)}`);\n    }\n  }\n\n  warn(message: string, context?: Record<string, unknown>): void {\n    if (this.shouldLog('warn')) {\n      console.warn(`[WARN] ${message}${this.formatContext(context)}`);\n    }\n  }\n\n  error(message: string, context?: Record<string, unknown>): void {\n    if (this.shouldLog('error')) {\n      console.error(`[ERROR] ${message}${this.formatContext(context)}`);\n    }\n  }\n}\n","/**\n * @happyvertical/logger - Structured logging for HAVE SDK\n *\n * Provides a structured logging interface with signal adapter integration.\n * Supports configurable log levels and console output.\n *\n * @example\n * ```typescript\n * import { createLogger, LoggerAdapter } from '@happyvertical/logger';\n *\n * // Create logger\n * const logger = createLogger({ level: 'info' });\n * logger.info('Application started');\n *\n * // Integrate with signals\n * const adapter = new LoggerAdapter(logger);\n * ```\n */\n\nexport { LoggerAdapter } from './adapter.js';\nexport { ConsoleLogger } from './console.js';\nexport type { Logger, LoggerConfig, LogLevel } from './logger.js';\nexport type { Signal, SignalAdapter, SignalType } from './signal-types.js';\n\nimport { loadEnvConfig } from '@happyvertical/utils';\nimport { ConsoleLogger } from './console.js';\nimport type { Logger, LoggerConfig, LogLevel } from './logger.js';\n\n/**\n * No-op logger that discards all log messages\n *\n * Used when logging is disabled (config: false)\n */\nclass NoopLogger implements Logger {\n  debug(_message: string, _context?: Record<string, unknown>): void {\n    // No-op\n  }\n\n  info(_message: string, _context?: Record<string, unknown>): void {\n    // No-op\n  }\n\n  warn(_message: string, _context?: Record<string, unknown>): void {\n    // No-op\n  }\n\n  error(_message: string, _context?: Record<string, unknown>): void {\n    // No-op\n  }\n}\n\n/**\n * Create a logger from configuration\n *\n * Supports environment variable configuration via HAVE_LOGGER_LEVEL.\n * User-provided options take precedence over environment variables.\n *\n * @param config - Logger configuration (boolean or object)\n * @returns Configured logger instance\n *\n * @example\n * ```typescript\n * // Console logger with 'info' level (default)\n * const logger1 = createLogger(true);\n *\n * // Console logger with level from HAVE_LOGGER_LEVEL env var\n * process.env.HAVE_LOGGER_LEVEL = 'debug';\n * const logger2 = createLogger(true); // Uses 'debug' from env\n *\n * // No-op logger (all log calls are discarded)\n * const logger3 = createLogger(false);\n *\n * // Console logger with 'debug' level (overrides env)\n * const logger4 = createLogger({ level: 'debug' });\n *\n * // Custom log level (user options take precedence)\n * process.env.HAVE_LOGGER_LEVEL = 'info';\n * const logger5 = createLogger({ level: 'warn' }); // Uses 'warn' not 'info'\n * ```\n */\nexport function createLogger(config: LoggerConfig): Logger {\n  if (typeof config === 'boolean') {\n    // When false, return no-op logger that discards all messages\n    if (!config) {\n      return new NoopLogger();\n    }\n\n    // Check HAVE_LOGGER_LEVEL env var when config is true\n    const envConfig = loadEnvConfig<{ level?: LogLevel }>(\n      {},\n      {\n        packageName: 'logger',\n        schema: { level: 'string' },\n      },\n    );\n\n    return new ConsoleLogger(envConfig.level || 'info');\n  }\n\n  // Merge user config with env vars (user options take precedence)\n  const mergedConfig = loadEnvConfig<{ level?: LogLevel }>(config, {\n    packageName: 'logger',\n    schema: { level: 'string' },\n  });\n\n  const level = mergedConfig.level || 'info';\n  return new ConsoleLogger(level);\n}\n\n/** @internal */\nexport const PACKAGE_VERSION_INITIALIZED = true;\n"],"names":["ConsoleLogger"],"mappings":"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"}

package/dist/logger.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Core logging interfaces and types
+ */
+/**
+ * Log levels in order of severity
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Logger configuration
+ * - boolean: true = console logger with 'info' level, false = disabled
+ * - object: configure logger with specific level
+ */
+export type LoggerConfig = boolean | {
+    level?: LogLevel;
+};
+/**
+ * Structured logger interface
+ *
+ * All methods accept optional context for structured logging.
+ * Context should contain machine-readable metadata.
+ */
+export interface Logger {
+    /**
+     * Log debug message (verbose development information)
+     *
+     * @param message - Human-readable log message
+     * @param context - Optional structured metadata
+     */
+    debug(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log informational message (normal operation)
+     *
+     * @param message - Human-readable log message
+     * @param context - Optional structured metadata
+     */
+    info(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log warning message (potential issues)
+     *
+     * @param message - Human-readable log message
+     * @param context - Optional structured metadata
+     */
+    warn(message: string, context?: Record<string, unknown>): void;
+    /**
+     * Log error message (failures and exceptions)
+     *
+     * @param message - Human-readable log message
+     * @param context - Optional structured metadata
+     */
+    error(message: string, context?: Record<string, unknown>): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG;IAAE,KAAK,CAAC,EAAE,QAAQ,CAAA;CAAE,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;OAKG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAEhE;;;;;OAKG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAE/D;;;;;OAKG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAE/D;;;;;OAKG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACjE"}

package/dist/sentry-adapter.d.ts

@@ -0,0 +1,45 @@
+import { Signal, SignalAdapter } from './signal-types.js';
+/**
+ * Configuration for the Sentry signal adapter
+ */
+export interface SentryAdapterConfig {
+    /** Breadcrumb category (default: 'smrt') */
+    category?: string;
+}
+/**
+ * Sentry signal adapter — routes SMRT signals to Sentry/GlitchTip
+ *
+ * Error signals are captured as exceptions with scope tags and context.
+ * All other signal types are added as breadcrumbs for debugging trail.
+ * Requires `@sentry/node` to be installed and `Sentry.init()` called before use.
+ *
+ * @example
+ * ```typescript
+ * import { createSentryAdapter } from '@happyvertical/logger/sentry';
+ *
+ * const adapter = createSentryAdapter({ category: 'myapp' });
+ * ```
+ */
+export declare class SentryAdapter implements SignalAdapter {
+    private category;
+    constructor(config?: SentryAdapterConfig);
+    /**
+     * Handle a signal by routing to Sentry
+     *
+     * Error signals are captured as exceptions. All other signal types
+     * are added as breadcrumbs.
+     *
+     * @param signal - The signal to handle
+     */
+    handle(signal: Signal): Promise<void>;
+    private captureError;
+    private addBreadcrumb;
+}
+/**
+ * Create a Sentry signal adapter
+ *
+ * @param config - Optional configuration (breadcrumb category)
+ * @returns Configured SentryAdapter instance
+ */
+export declare function createSentryAdapter(config?: SentryAdapterConfig): SentryAdapter;
+//# sourceMappingURL=sentry-adapter.d.ts.map

package/dist/sentry-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry-adapter.d.ts","sourceRoot":"","sources":["../src/sentry-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAc,YAAW,aAAa;IACjD,OAAO,CAAC,QAAQ,CAAS;gBAEb,MAAM,CAAC,EAAE,mBAAmB;IAIxC;;;;;;;OAOG;IACG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3C,OAAO,CAAC,YAAY;IAkBpB,OAAO,CAAC,aAAa;CAqCtB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,CAAC,EAAE,mBAAmB,GAC3B,aAAa,CAEf"}

package/dist/sentry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sentry adapter subpath entry point
+ *
+ * Import via: import { createSentryAdapter } from '@happyvertical/logger/sentry';
+ */
+export type { SentryAdapterConfig } from './sentry-adapter.js';
+export { createSentryAdapter, SentryAdapter } from './sentry-adapter.js';
+//# sourceMappingURL=sentry.d.ts.map

package/dist/sentry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry.d.ts","sourceRoot":"","sources":["../src/sentry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/sentry.js

@@ -0,0 +1,79 @@
+import * as Sentry from "@sentry/node";
+class SentryAdapter {
+  category;
+  constructor(config) {
+    this.category = config?.category ?? "smrt";
+  }
+  /**
+   * Handle a signal by routing to Sentry
+   *
+   * Error signals are captured as exceptions. All other signal types
+   * are added as breadcrumbs.
+   *
+   * @param signal - The signal to handle
+   */
+  async handle(signal) {
+    if (signal.type === "error") {
+      this.captureError(signal);
+    } else {
+      this.addBreadcrumb(signal);
+    }
+  }
+  captureError(signal) {
+    const error = signal.error ?? new Error("Unknown SMRT error");
+    Sentry.withScope((scope) => {
+      scope.setTag("smrt.class", signal.className);
+      scope.setTag("smrt.method", signal.method);
+      scope.setContext("smrt", {
+        signalId: signal.id,
+        objectId: signal.objectId,
+        duration: signal.duration,
+        ...signal.metadata
+      });
+      Sentry.captureException(error);
+    });
+  }
+  addBreadcrumb(signal) {
+    const levelMap = {
+      start: "debug",
+      step: "debug",
+      end: "info",
+      error: "error"
+    };
+    let message;
+    switch (signal.type) {
+      case "start":
+        message = `${signal.className}.${signal.method}() started`;
+        break;
+      case "step":
+        message = `${signal.className}.${signal.method}() step: ${signal.step || "unknown"}`;
+        break;
+      case "end":
+        message = `${signal.className}.${signal.method}() completed in ${signal.duration}ms`;
+        break;
+      default:
+        message = `${signal.className}.${signal.method}() ${signal.type}`;
+    }
+    Sentry.addBreadcrumb({
+      category: this.category,
+      message,
+      level: levelMap[signal.type] || "info",
+      data: {
+        signalId: signal.id,
+        objectId: signal.objectId,
+        className: signal.className,
+        method: signal.method,
+        ...signal.duration !== void 0 && { duration: signal.duration },
+        ...signal.metadata
+      }
+    });
+  }
+}
+function createSentryAdapter(config) {
+  return new SentryAdapter(config);
+}
+export {
+  SentryAdapter,
+  createSentryAdapter
+};
+//# sourceMappingURL=sentry.js.map

package/dist/sentry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry.js","sources":["../src/sentry-adapter.ts"],"sourcesContent":["/**\n * Sentry signal adapter for error tracking\n *\n * Routes SMRT framework signals to Sentry/GlitchTip:\n * - Error signals → Sentry.captureException with scope tags and context\n * - Non-error signals → Sentry.addBreadcrumb for debugging trail\n *\n * Consumer must install @sentry/node and call Sentry.init() before use.\n */\n\nimport * as Sentry from '@sentry/node';\nimport type { Signal, SignalAdapter } from './signal-types.js';\n\n/**\n * Configuration for the Sentry signal adapter\n */\nexport interface SentryAdapterConfig {\n  /** Breadcrumb category (default: 'smrt') */\n  category?: string;\n}\n\n/**\n * Sentry signal adapter — routes SMRT signals to Sentry/GlitchTip\n *\n * Error signals are captured as exceptions with scope tags and context.\n * All other signal types are added as breadcrumbs for debugging trail.\n * Requires `@sentry/node` to be installed and `Sentry.init()` called before use.\n *\n * @example\n * ```typescript\n * import { createSentryAdapter } from '@happyvertical/logger/sentry';\n *\n * const adapter = createSentryAdapter({ category: 'myapp' });\n * ```\n */\nexport class SentryAdapter implements SignalAdapter {\n  private category: string;\n\n  constructor(config?: SentryAdapterConfig) {\n    this.category = config?.category ?? 'smrt';\n  }\n\n  /**\n   * Handle a signal by routing to Sentry\n   *\n   * Error signals are captured as exceptions. All other signal types\n   * are added as breadcrumbs.\n   *\n   * @param signal - The signal to handle\n   */\n  async handle(signal: Signal): Promise<void> {\n    if (signal.type === 'error') {\n      this.captureError(signal);\n    } else {\n      this.addBreadcrumb(signal);\n    }\n  }\n\n  private captureError(signal: Signal): void {\n    const error = signal.error ?? new Error('Unknown SMRT error');\n\n    Sentry.withScope((scope) => {\n      scope.setTag('smrt.class', signal.className);\n      scope.setTag('smrt.method', signal.method);\n\n      scope.setContext('smrt', {\n        signalId: signal.id,\n        objectId: signal.objectId,\n        duration: signal.duration,\n        ...signal.metadata,\n      });\n\n      Sentry.captureException(error);\n    });\n  }\n\n  private addBreadcrumb(signal: Signal): void {\n    const levelMap: Record<string, Sentry.SeverityLevel> = {\n      start: 'debug',\n      step: 'debug',\n      end: 'info',\n      error: 'error',\n    };\n\n    let message: string;\n    switch (signal.type) {\n      case 'start':\n        message = `${signal.className}.${signal.method}() started`;\n        break;\n      case 'step':\n        message = `${signal.className}.${signal.method}() step: ${signal.step || 'unknown'}`;\n        break;\n      case 'end':\n        message = `${signal.className}.${signal.method}() completed in ${signal.duration}ms`;\n        break;\n      default:\n        message = `${signal.className}.${signal.method}() ${signal.type}`;\n    }\n\n    Sentry.addBreadcrumb({\n      category: this.category,\n      message,\n      level: levelMap[signal.type] || 'info',\n      data: {\n        signalId: signal.id,\n        objectId: signal.objectId,\n        className: signal.className,\n        method: signal.method,\n        ...(signal.duration !== undefined && { duration: signal.duration }),\n        ...signal.metadata,\n      },\n    });\n  }\n}\n\n/**\n * Create a Sentry signal adapter\n *\n * @param config - Optional configuration (breadcrumb category)\n * @returns Configured SentryAdapter instance\n */\nexport function createSentryAdapter(\n  config?: SentryAdapterConfig,\n): SentryAdapter {\n  return new SentryAdapter(config);\n}\n"],"names":[],"mappings":";AAmCO,MAAM,cAAuC;AAAA,EAC1C;AAAA,EAER,YAAY,QAA8B;AACxC,SAAK,WAAW,QAAQ,YAAY;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,MAAM,OAAO,QAA+B;AAC1C,QAAI,OAAO,SAAS,SAAS;AAC3B,WAAK,aAAa,MAAM;AAAA,IAC1B,OAAO;AACL,WAAK,cAAc,MAAM;AAAA,IAC3B;AAAA,EACF;AAAA,EAEQ,aAAa,QAAsB;AACzC,UAAM,QAAQ,OAAO,SAAS,IAAI,MAAM,oBAAoB;AAE5D,WAAO,UAAU,CAAC,UAAU;AAC1B,YAAM,OAAO,cAAc,OAAO,SAAS;AAC3C,YAAM,OAAO,eAAe,OAAO,MAAM;AAEzC,YAAM,WAAW,QAAQ;AAAA,QACvB,UAAU,OAAO;AAAA,QACjB,UAAU,OAAO;AAAA,QACjB,UAAU,OAAO;AAAA,QACjB,GAAG,OAAO;AAAA,MAAA,CACX;AAED,aAAO,iBAAiB,KAAK;AAAA,IAC/B,CAAC;AAAA,EACH;AAAA,EAEQ,cAAc,QAAsB;AAC1C,UAAM,WAAiD;AAAA,MACrD,OAAO;AAAA,MACP,MAAM;AAAA,MACN,KAAK;AAAA,MACL,OAAO;AAAA,IAAA;AAGT,QAAI;AACJ,YAAQ,OAAO,MAAA;AAAA,MACb,KAAK;AACH,kBAAU,GAAG,OAAO,SAAS,IAAI,OAAO,MAAM;AAC9C;AAAA,MACF,KAAK;AACH,kBAAU,GAAG,OAAO,SAAS,IAAI,OAAO,MAAM,YAAY,OAAO,QAAQ,SAAS;AAClF;AAAA,MACF,KAAK;AACH,kBAAU,GAAG,OAAO,SAAS,IAAI,OAAO,MAAM,mBAAmB,OAAO,QAAQ;AAChF;AAAA,MACF;AACE,kBAAU,GAAG,OAAO,SAAS,IAAI,OAAO,MAAM,MAAM,OAAO,IAAI;AAAA,IAAA;AAGnE,WAAO,cAAc;AAAA,MACnB,UAAU,KAAK;AAAA,MACf;AAAA,MACA,OAAO,SAAS,OAAO,IAAI,KAAK;AAAA,MAChC,MAAM;AAAA,QACJ,UAAU,OAAO;AAAA,QACjB,UAAU,OAAO;AAAA,QACjB,WAAW,OAAO;AAAA,QAClB,QAAQ,OAAO;AAAA,QACf,GAAI,OAAO,aAAa,UAAa,EAAE,UAAU,OAAO,SAAA;AAAA,QACxD,GAAG,OAAO;AAAA,MAAA;AAAA,IACZ,CACD;AAAA,EACH;AACF;AAQO,SAAS,oBACd,QACe;AACf,SAAO,IAAI,cAAc,MAAM;AACjC;"}

package/dist/signal-types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Local Signal type definitions for logger adapter
+ * These types are copied from @happyvertical/types to keep logger independent
+ */
+/**
+ * Signal types representing different phases of operation execution
+ */
+export type SignalType = 'start' | 'step' | 'end' | 'error';
+/**
+ * Signal - Represents an event in operation execution
+ */
+export interface Signal {
+    /** Unique signal ID */
+    id: string;
+    /** Signal type */
+    type: SignalType;
+    /** Object ID that emitted the signal */
+    objectId: string;
+    /** Class name of the emitting object */
+    className: string;
+    /** Method name that emitted the signal */
+    method: string;
+    /** Timestamp when signal was emitted */
+    timestamp: Date;
+    /** Step description (for 'step' type signals) */
+    step?: string;
+    /** Operation duration in milliseconds (for 'end' type signals) */
+    duration?: number;
+    /** Operation result (for 'end' type signals) */
+    result?: unknown;
+    /** Error information (for 'error' type signals) */
+    error?: Error;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Signal Adapter interface - Handles signals for various purposes
+ */
+export interface SignalAdapter {
+    /**
+     * Handle a signal
+     * @param signal - The signal to handle
+     */
+    handle(signal: Signal): Promise<void>;
+}
+//# sourceMappingURL=signal-types.d.ts.map

package/dist/signal-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-types.d.ts","sourceRoot":"","sources":["../src/signal-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,uBAAuB;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,kBAAkB;IAClB,IAAI,EAAE,UAAU,CAAC;IACjB,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,wCAAwC;IACxC,SAAS,EAAE,IAAI,CAAC;IAChB,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,mDAAmD;IACnD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC"}

package/dist/test-logger.d.ts

@@ -0,0 +1,56 @@
+import { Logger, LogLevel } from './logger.js';
+/**
+ * Log entry captured by TestLogger
+ */
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    context?: Record<string, unknown>;
+    timestamp: number;
+}
+/**
+ * Test logger that captures log entries in memory
+ *
+ * Useful for testing code that uses loggers without:
+ * - Mocking logger methods with vi.fn()
+ * - Spying on console output
+ * - Writing to actual log files
+ *
+ * Provides a real Logger implementation that can be inspected in tests.
+ */
+export declare class TestLogger implements Logger {
+    /**
+     * All log entries captured by this logger
+     */
+    readonly entries: LogEntry[];
+    /**
+     * Minimum log level to capture (optional filtering)
+     */
+    private level?;
+    constructor(level?: LogLevel);
+    /**
+     * Get entries of a specific level
+     */
+    getEntriesByLevel(level: LogLevel): LogEntry[];
+    /**
+     * Get the most recent entry
+     */
+    getLastEntry(): LogEntry | undefined;
+    /**
+     * Check if a log level should be captured
+     */
+    private shouldLog;
+    /**
+     * Capture a log entry
+     */
+    private log;
+    /**
+     * Clear all captured entries
+     */
+    clear(): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+}
+//# sourceMappingURL=test-logger.d.ts.map

package/dist/test-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-logger.d.ts","sourceRoot":"","sources":["../src/test-logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,qBAAa,UAAW,YAAW,MAAM;IACvC;;OAEG;IACH,SAAgB,OAAO,EAAE,QAAQ,EAAE,CAAM;IAEzC;;OAEG;IACH,OAAO,CAAC,KAAK,CAAC,CAAW;gBAEb,KAAK,CAAC,EAAE,QAAQ;IAI5B;;OAEG;IACH,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,EAAE;IAI9C;;OAEG;IACH,YAAY,IAAI,QAAQ,GAAG,SAAS;IAIpC;;OAEG;IACH,OAAO,CAAC,SAAS;IASjB;;OAEG;IACH,OAAO,CAAC,GAAG;IAeX;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAGhE"}

package/metadata.json

@@ -0,0 +1,37 @@
+{
+  "name": "@happyvertical/logger",
+  "path": "packages/logger",
+  "position": {
+    "index": 18,
+    "count": 30
+  },
+  "description": "Structured logging for HAVE SDK with signal adapter",
+  "provides": [
+    "Structured logging for HAVE SDK with signal adapter"
+  ],
+  "implements": [],
+  "requires": {
+    "workspace": [
+      "@happyvertical/utils"
+    ],
+    "externalHappyVertical": [],
+    "external": [
+      "@sentry/node"
+    ]
+  },
+  "dependents": [
+    "@happyvertical/comfyui",
+    "@happyvertical/email",
+    "@happyvertical/encryption",
+    "@happyvertical/messages",
+    "@happyvertical/social",
+    "@happyvertical/video"
+  ],
+  "stability": {
+    "level": "stable",
+    "reason": "Primary package surface is described as implemented and production-oriented."
+  },
+  "keywords": [
+    "logger"
+  ]
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@happyvertical/logger",
+  "version": "0.74.8",
+  "description": "Structured logging for HAVE SDK with signal adapter",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./sentry": {
+      "import": "./dist/sentry.js",
+      "types": "./dist/sentry.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "@sentry/node": ">=10.49.0"
+  },
+  "peerDependenciesMeta": {
+    "@sentry/node": {
+      "optional": true
+    }
+  },
+  "bin": {
+    "have-logger-context": "./dist/cli/claude-context.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "AGENT.md",
+    "metadata.json"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "dependencies": {
+    "@happyvertical/utils": "0.74.8"
+  },
+  "devDependencies": {
+    "@sentry/node": "^10.49.0",
+    "@types/node": "25.0.10",
+    "typescript": "^5.9.3",
+    "vite": "7.3.2",
+    "vitest": "^4.1.5"
+  },
+  "keywords": [
+    "logging",
+    "structured-logging",
+    "signals",
+    "observability",
+    "have-sdk"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/happyvertical/sdk.git",
+    "directory": "packages/logger"
+  },
+  "bugs": {
+    "url": "https://github.com/happyvertical/sdk/issues"
+  },
+  "homepage": "https://github.com/happyvertical/sdk/tree/main/packages/logger#readme",
+  "license": "MIT",
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}