luzzi-analytics 0.1.0

package/README.md

@@ -0,0 +1,94 @@
+# @luzzi/analytics
+
+Simple, plug-and-play analytics SDK for solo builders.
+
+## Installation
+
+```bash
+npm install @luzzi/analytics
+```
+
+## Quick Start
+
+```typescript
+import luzzi from "@luzzi/analytics";
+
+// Initialize with your API key
+luzzi.init("pk_live_xxx");
+
+// Track events
+luzzi.track("button_clicked", { button: "signup" });
+
+// Identify users
+luzzi.identify("user_123", { plan: "pro" });
+
+// Reset on logout
+luzzi.reset();
+```
+
+## API
+
+### `init(apiKey, config?)`
+
+Initialize the SDK. Must be called before any other method.
+
+```typescript
+luzzi.init("pk_live_xxx", {
+  apiUrl: "https://api.luzzi.dev", // Custom API URL (optional)
+  batchSize: 10, // Events to batch before sending (default: 10)
+  flushInterval: 30000, // Flush interval in ms (default: 30s)
+  debug: false, // Enable debug logging (default: false)
+});
+```
+
+### `track(eventName, properties?)`
+
+Track an event with optional properties.
+
+```typescript
+luzzi.track("purchase_completed", {
+  amount: 99.99,
+  currency: "USD",
+  product_id: "prod_123",
+});
+```
+
+### `identify(userId, traits?)`
+
+Identify the current user with optional traits.
+
+```typescript
+luzzi.identify("user_123", {
+  email: "user@example.com",
+  plan: "pro",
+  created_at: "2024-01-01",
+});
+```
+
+### `reset()`
+
+Reset the current user. Call this on logout.
+
+```typescript
+luzzi.reset();
+```
+
+### `flush()`
+
+Manually flush pending events to the server.
+
+```typescript
+await luzzi.flush();
+```
+
+## Automatic Features
+
+- **Session tracking**: Automatically generates a unique session ID
+- **Device info**: Collects OS, browser, screen size, language, timezone
+- **Batching**: Events are batched (10 events or 30 seconds)
+- **Auto-flush**: Events are flushed on page unload/visibility change
+- **Retry**: Failed events are re-queued and retried
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,118 @@
+/**
+ * Luzzi Analytics SDK Types
+ */
+interface LuzziConfig {
+    /** API endpoint URL (defaults to https://api.luzzi.dev) */
+    apiUrl?: string;
+    /** Batch size before auto-flush (default: 10) */
+    batchSize?: number;
+    /** Flush interval in milliseconds (default: 30000 = 30s) */
+    flushInterval?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+interface DeviceInfo {
+    os?: string;
+    app_version?: string;
+    browser?: string;
+    screen_width?: number;
+    screen_height?: number;
+    language?: string;
+    timezone?: string;
+}
+interface EventPayload {
+    event: string;
+    properties?: Record<string, unknown>;
+    timestamp: string;
+    session_id: string;
+    user_id?: string;
+    device: DeviceInfo;
+}
+interface UserTraits {
+    [key: string]: unknown;
+}
+
+/**
+ * Luzzi Analytics SDK
+ *
+ * Simple, plug-and-play analytics for solo builders.
+ *
+ * @example
+ * ```typescript
+ * import luzzi from "@luzzi/analytics";
+ *
+ * // Initialize with your API key
+ * luzzi.init("pk_live_xxx");
+ *
+ * // Track events
+ * luzzi.track("button_clicked", { button: "signup" });
+ *
+ * // Identify users
+ * luzzi.identify("user_123", { plan: "pro" });
+ *
+ * // Reset on logout
+ * luzzi.reset();
+ * ```
+ */
+
+/**
+ * Luzzi Analytics SDK
+ */
+declare const luzzi: {
+    /**
+     * Initialize the SDK with your API key
+     * Must be called before any other method
+     *
+     * @param apiKey - Your Luzzi API key (pk_live_xxx or pk_test_xxx)
+     * @param config - Optional configuration
+     */
+    init: (apiKey: string, config?: LuzziConfig) => void;
+    /**
+     * Track an event
+     *
+     * @param eventName - Name of the event (e.g., "button_clicked", "page_viewed")
+     * @param properties - Optional event properties
+     *
+     * @example
+     * luzzi.track("purchase_completed", { amount: 99.99, currency: "USD" });
+     */
+    track: (eventName: string, properties?: Record<string, unknown>) => void;
+    /**
+     * Identify the current user
+     *
+     * @param userId - Unique user identifier
+     * @param traits - Optional user traits/properties
+     *
+     * @example
+     * luzzi.identify("user_123", { email: "user@example.com", plan: "pro" });
+     */
+    identify: (userId: string, traits?: UserTraits) => void;
+    /**
+     * Reset the current user (call on logout)
+     * Clears user ID and generates a new session
+     */
+    reset: () => void;
+    /**
+     * Manually flush pending events to the server
+     * Events are automatically flushed on a timer and on page unload
+     */
+    flush: () => Promise<void>;
+    /**
+     * Get the current session ID
+     */
+    getSessionId: () => string;
+    /**
+     * Get the current user ID (if identified)
+     */
+    getUserId: () => string | undefined;
+};
+
+declare const init: (apiKey: string, config?: LuzziConfig) => void;
+declare const track: (eventName: string, properties?: Record<string, unknown>) => void;
+declare const identify: (userId: string, traits?: UserTraits) => void;
+declare const reset: () => void;
+declare const flush: () => Promise<void>;
+declare const getSessionId: () => string;
+declare const getUserId: () => string | undefined;
+
+export { type DeviceInfo, type EventPayload, type LuzziConfig, type UserTraits, luzzi as default, flush, getSessionId, getUserId, identify, init, reset, track };

package/dist/index.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Luzzi Analytics SDK Types
+ */
+interface LuzziConfig {
+    /** API endpoint URL (defaults to https://api.luzzi.dev) */
+    apiUrl?: string;
+    /** Batch size before auto-flush (default: 10) */
+    batchSize?: number;
+    /** Flush interval in milliseconds (default: 30000 = 30s) */
+    flushInterval?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+interface DeviceInfo {
+    os?: string;
+    app_version?: string;
+    browser?: string;
+    screen_width?: number;
+    screen_height?: number;
+    language?: string;
+    timezone?: string;
+}
+interface EventPayload {
+    event: string;
+    properties?: Record<string, unknown>;
+    timestamp: string;
+    session_id: string;
+    user_id?: string;
+    device: DeviceInfo;
+}
+interface UserTraits {
+    [key: string]: unknown;
+}
+
+/**
+ * Luzzi Analytics SDK
+ *
+ * Simple, plug-and-play analytics for solo builders.
+ *
+ * @example
+ * ```typescript
+ * import luzzi from "@luzzi/analytics";
+ *
+ * // Initialize with your API key
+ * luzzi.init("pk_live_xxx");
+ *
+ * // Track events
+ * luzzi.track("button_clicked", { button: "signup" });
+ *
+ * // Identify users
+ * luzzi.identify("user_123", { plan: "pro" });
+ *
+ * // Reset on logout
+ * luzzi.reset();
+ * ```
+ */
+
+/**
+ * Luzzi Analytics SDK
+ */
+declare const luzzi: {
+    /**
+     * Initialize the SDK with your API key
+     * Must be called before any other method
+     *
+     * @param apiKey - Your Luzzi API key (pk_live_xxx or pk_test_xxx)
+     * @param config - Optional configuration
+     */
+    init: (apiKey: string, config?: LuzziConfig) => void;
+    /**
+     * Track an event
+     *
+     * @param eventName - Name of the event (e.g., "button_clicked", "page_viewed")
+     * @param properties - Optional event properties
+     *
+     * @example
+     * luzzi.track("purchase_completed", { amount: 99.99, currency: "USD" });
+     */
+    track: (eventName: string, properties?: Record<string, unknown>) => void;
+    /**
+     * Identify the current user
+     *
+     * @param userId - Unique user identifier
+     * @param traits - Optional user traits/properties
+     *
+     * @example
+     * luzzi.identify("user_123", { email: "user@example.com", plan: "pro" });
+     */
+    identify: (userId: string, traits?: UserTraits) => void;
+    /**
+     * Reset the current user (call on logout)
+     * Clears user ID and generates a new session
+     */
+    reset: () => void;
+    /**
+     * Manually flush pending events to the server
+     * Events are automatically flushed on a timer and on page unload
+     */
+    flush: () => Promise<void>;
+    /**
+     * Get the current session ID
+     */
+    getSessionId: () => string;
+    /**
+     * Get the current user ID (if identified)
+     */
+    getUserId: () => string | undefined;
+};
+
+declare const init: (apiKey: string, config?: LuzziConfig) => void;
+declare const track: (eventName: string, properties?: Record<string, unknown>) => void;
+declare const identify: (userId: string, traits?: UserTraits) => void;
+declare const reset: () => void;
+declare const flush: () => Promise<void>;
+declare const getSessionId: () => string;
+declare const getUserId: () => string | undefined;
+
+export { type DeviceInfo, type EventPayload, type LuzziConfig, type UserTraits, luzzi as default, flush, getSessionId, getUserId, identify, init, reset, track };

package/dist/index.js

@@ -0,0 +1,390 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  flush: () => flush,
+  getSessionId: () => getSessionId,
+  getUserId: () => getUserId,
+  identify: () => identify,
+  init: () => init,
+  reset: () => reset,
+  track: () => track
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/queue.ts
+var EventQueue = class {
+  constructor() {
+    this.queue = [];
+    this.flushTimer = null;
+    this.apiKey = "";
+    this.apiUrl = "";
+    this.batchSize = 10;
+    this.flushInterval = 3e4;
+    this.debug = false;
+  }
+  /**
+   * Initialize the queue
+   */
+  init(apiKey, apiUrl, batchSize, flushInterval, debug) {
+    this.apiKey = apiKey;
+    this.apiUrl = apiUrl;
+    this.batchSize = batchSize;
+    this.flushInterval = flushInterval;
+    this.debug = debug;
+    this.startFlushTimer();
+  }
+  /**
+   * Add event to queue
+   */
+  push(event) {
+    this.queue.push(event);
+    this.log(`Event queued: ${event.event}`, event);
+    if (this.queue.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Flush all events in queue to server
+   */
+  async flush() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    const events = [...this.queue];
+    this.queue = [];
+    try {
+      const payload = { events };
+      this.log(`Flushing ${events.length} events`, payload);
+      const response = await fetch(`${this.apiUrl}/v1/events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error("[Luzzi] Failed to send events:", error);
+        if (this.queue.length < this.batchSize * 10) {
+          this.queue.unshift(...events);
+        }
+      } else {
+        const result = await response.json();
+        this.log(`Events sent successfully`, result);
+      }
+    } catch (error) {
+      console.error("[Luzzi] Failed to send events:", error);
+      if (this.queue.length < this.batchSize * 10) {
+        this.queue.unshift(...events);
+      }
+    }
+  }
+  /**
+   * Start auto-flush timer
+   */
+  startFlushTimer() {
+    this.stopFlushTimer();
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  /**
+   * Stop auto-flush timer
+   */
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  /**
+   * Get queue length
+   */
+  get length() {
+    return this.queue.length;
+  }
+  /**
+   * Clear queue and stop timer
+   */
+  reset() {
+    this.queue = [];
+    this.stopFlushTimer();
+  }
+  /**
+   * Debug log
+   */
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[Luzzi] ${message}`, data || "");
+    }
+  }
+};
+
+// src/core.ts
+var DEFAULT_API_URL = "https://luzzi.vercel.app/api";
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_FLUSH_INTERVAL = 3e4;
+var LuzziCore = class {
+  constructor() {
+    this.apiKey = "";
+    this.apiUrl = DEFAULT_API_URL;
+    this.sessionId = "";
+    this.userTraits = {};
+    this.deviceInfo = {};
+    this.initialized = false;
+    this.debug = false;
+    this.queue = new EventQueue();
+  }
+  /**
+   * Initialize the SDK
+   * Must be called before any other method
+   */
+  init(apiKey, config = {}) {
+    if (!apiKey) {
+      console.error("[Luzzi] API key is required");
+      return;
+    }
+    this.apiKey = apiKey;
+    this.apiUrl = config.apiUrl || DEFAULT_API_URL;
+    this.debug = config.debug || false;
+    this.sessionId = this.generateSessionId();
+    this.deviceInfo = this.collectDeviceInfo();
+    this.queue.init(
+      this.apiKey,
+      this.apiUrl,
+      config.batchSize || DEFAULT_BATCH_SIZE,
+      config.flushInterval || DEFAULT_FLUSH_INTERVAL,
+      this.debug
+    );
+    this.initialized = true;
+    this.log("Initialized", { apiKey: apiKey.slice(0, 10) + "...", sessionId: this.sessionId });
+    if (typeof window !== "undefined") {
+      window.addEventListener("beforeunload", () => {
+        this.flush();
+      });
+      window.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") {
+          this.flush();
+        }
+      });
+    }
+  }
+  /**
+   * Track an event
+   */
+  track(eventName, properties) {
+    if (!this.initialized) {
+      console.warn("[Luzzi] SDK not initialized. Call luzzi.init() first.");
+      return;
+    }
+    if (!eventName || typeof eventName !== "string") {
+      console.warn("[Luzzi] Event name is required and must be a string");
+      return;
+    }
+    this.queue.push({
+      event: eventName,
+      properties: properties || {},
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      session_id: this.sessionId,
+      user_id: this.userId,
+      device: this.deviceInfo
+    });
+  }
+  /**
+   * Identify the current user
+   */
+  identify(userId, traits) {
+    if (!this.initialized) {
+      console.warn("[Luzzi] SDK not initialized. Call luzzi.init() first.");
+      return;
+    }
+    if (!userId || typeof userId !== "string") {
+      console.warn("[Luzzi] User ID is required and must be a string");
+      return;
+    }
+    this.userId = userId;
+    this.userTraits = { ...this.userTraits, ...traits };
+    this.log("User identified", { userId, traits });
+    this.track("$identify", {
+      ...this.userTraits,
+      $user_id: userId
+    });
+  }
+  /**
+   * Reset the current user (logout)
+   */
+  reset() {
+    this.log("Resetting user");
+    this.flush();
+    this.userId = void 0;
+    this.userTraits = {};
+    this.sessionId = this.generateSessionId();
+    this.log("Reset complete", { newSessionId: this.sessionId });
+  }
+  /**
+   * Manually flush the event queue
+   */
+  async flush() {
+    if (!this.initialized) {
+      return;
+    }
+    await this.queue.flush();
+  }
+  /**
+   * Get the current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Get the current user ID
+   */
+  getUserId() {
+    return this.userId;
+  }
+  /**
+   * Generate a unique session ID
+   */
+  generateSessionId() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+  }
+  /**
+   * Collect device information
+   */
+  collectDeviceInfo() {
+    const info = {};
+    if (typeof window !== "undefined" && typeof navigator !== "undefined") {
+      const ua = navigator.userAgent;
+      if (ua.includes("Windows")) info.os = "windows";
+      else if (ua.includes("Mac")) info.os = "macos";
+      else if (ua.includes("Linux")) info.os = "linux";
+      else if (ua.includes("Android")) info.os = "android";
+      else if (ua.includes("iPhone") || ua.includes("iPad")) info.os = "ios";
+      if (ua.includes("Chrome") && !ua.includes("Edg")) info.browser = "chrome";
+      else if (ua.includes("Firefox")) info.browser = "firefox";
+      else if (ua.includes("Safari") && !ua.includes("Chrome")) info.browser = "safari";
+      else if (ua.includes("Edg")) info.browser = "edge";
+      info.screen_width = window.screen?.width;
+      info.screen_height = window.screen?.height;
+      info.language = navigator.language;
+      try {
+        info.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      } catch {
+      }
+    }
+    if (typeof process !== "undefined" && process.versions?.node) {
+      info.os = process.platform;
+      info.app_version = process.versions.node;
+    }
+    return info;
+  }
+  /**
+   * Debug log
+   */
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[Luzzi] ${message}`, data || "");
+    }
+  }
+};
+var luzziCore = new LuzziCore();
+
+// src/index.ts
+var luzzi = {
+  /**
+   * Initialize the SDK with your API key
+   * Must be called before any other method
+   *
+   * @param apiKey - Your Luzzi API key (pk_live_xxx or pk_test_xxx)
+   * @param config - Optional configuration
+   */
+  init: (apiKey, config) => {
+    luzziCore.init(apiKey, config);
+  },
+  /**
+   * Track an event
+   *
+   * @param eventName - Name of the event (e.g., "button_clicked", "page_viewed")
+   * @param properties - Optional event properties
+   *
+   * @example
+   * luzzi.track("purchase_completed", { amount: 99.99, currency: "USD" });
+   */
+  track: (eventName, properties) => {
+    luzziCore.track(eventName, properties);
+  },
+  /**
+   * Identify the current user
+   *
+   * @param userId - Unique user identifier
+   * @param traits - Optional user traits/properties
+   *
+   * @example
+   * luzzi.identify("user_123", { email: "user@example.com", plan: "pro" });
+   */
+  identify: (userId, traits) => {
+    luzziCore.identify(userId, traits);
+  },
+  /**
+   * Reset the current user (call on logout)
+   * Clears user ID and generates a new session
+   */
+  reset: () => {
+    luzziCore.reset();
+  },
+  /**
+   * Manually flush pending events to the server
+   * Events are automatically flushed on a timer and on page unload
+   */
+  flush: () => {
+    return luzziCore.flush();
+  },
+  /**
+   * Get the current session ID
+   */
+  getSessionId: () => {
+    return luzziCore.getSessionId();
+  },
+  /**
+   * Get the current user ID (if identified)
+   */
+  getUserId: () => {
+    return luzziCore.getUserId();
+  }
+};
+var index_default = luzzi;
+var { init, track, identify, reset, flush, getSessionId, getUserId } = luzzi;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flush,
+  getSessionId,
+  getUserId,
+  identify,
+  init,
+  reset,
+  track
+});

package/dist/index.mjs

@@ -0,0 +1,357 @@
+// src/queue.ts
+var EventQueue = class {
+  constructor() {
+    this.queue = [];
+    this.flushTimer = null;
+    this.apiKey = "";
+    this.apiUrl = "";
+    this.batchSize = 10;
+    this.flushInterval = 3e4;
+    this.debug = false;
+  }
+  /**
+   * Initialize the queue
+   */
+  init(apiKey, apiUrl, batchSize, flushInterval, debug) {
+    this.apiKey = apiKey;
+    this.apiUrl = apiUrl;
+    this.batchSize = batchSize;
+    this.flushInterval = flushInterval;
+    this.debug = debug;
+    this.startFlushTimer();
+  }
+  /**
+   * Add event to queue
+   */
+  push(event) {
+    this.queue.push(event);
+    this.log(`Event queued: ${event.event}`, event);
+    if (this.queue.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Flush all events in queue to server
+   */
+  async flush() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    const events = [...this.queue];
+    this.queue = [];
+    try {
+      const payload = { events };
+      this.log(`Flushing ${events.length} events`, payload);
+      const response = await fetch(`${this.apiUrl}/v1/events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error("[Luzzi] Failed to send events:", error);
+        if (this.queue.length < this.batchSize * 10) {
+          this.queue.unshift(...events);
+        }
+      } else {
+        const result = await response.json();
+        this.log(`Events sent successfully`, result);
+      }
+    } catch (error) {
+      console.error("[Luzzi] Failed to send events:", error);
+      if (this.queue.length < this.batchSize * 10) {
+        this.queue.unshift(...events);
+      }
+    }
+  }
+  /**
+   * Start auto-flush timer
+   */
+  startFlushTimer() {
+    this.stopFlushTimer();
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.flushInterval);
+  }
+  /**
+   * Stop auto-flush timer
+   */
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  /**
+   * Get queue length
+   */
+  get length() {
+    return this.queue.length;
+  }
+  /**
+   * Clear queue and stop timer
+   */
+  reset() {
+    this.queue = [];
+    this.stopFlushTimer();
+  }
+  /**
+   * Debug log
+   */
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[Luzzi] ${message}`, data || "");
+    }
+  }
+};
+
+// src/core.ts
+var DEFAULT_API_URL = "https://luzzi.vercel.app/api";
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_FLUSH_INTERVAL = 3e4;
+var LuzziCore = class {
+  constructor() {
+    this.apiKey = "";
+    this.apiUrl = DEFAULT_API_URL;
+    this.sessionId = "";
+    this.userTraits = {};
+    this.deviceInfo = {};
+    this.initialized = false;
+    this.debug = false;
+    this.queue = new EventQueue();
+  }
+  /**
+   * Initialize the SDK
+   * Must be called before any other method
+   */
+  init(apiKey, config = {}) {
+    if (!apiKey) {
+      console.error("[Luzzi] API key is required");
+      return;
+    }
+    this.apiKey = apiKey;
+    this.apiUrl = config.apiUrl || DEFAULT_API_URL;
+    this.debug = config.debug || false;
+    this.sessionId = this.generateSessionId();
+    this.deviceInfo = this.collectDeviceInfo();
+    this.queue.init(
+      this.apiKey,
+      this.apiUrl,
+      config.batchSize || DEFAULT_BATCH_SIZE,
+      config.flushInterval || DEFAULT_FLUSH_INTERVAL,
+      this.debug
+    );
+    this.initialized = true;
+    this.log("Initialized", { apiKey: apiKey.slice(0, 10) + "...", sessionId: this.sessionId });
+    if (typeof window !== "undefined") {
+      window.addEventListener("beforeunload", () => {
+        this.flush();
+      });
+      window.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "hidden") {
+          this.flush();
+        }
+      });
+    }
+  }
+  /**
+   * Track an event
+   */
+  track(eventName, properties) {
+    if (!this.initialized) {
+      console.warn("[Luzzi] SDK not initialized. Call luzzi.init() first.");
+      return;
+    }
+    if (!eventName || typeof eventName !== "string") {
+      console.warn("[Luzzi] Event name is required and must be a string");
+      return;
+    }
+    this.queue.push({
+      event: eventName,
+      properties: properties || {},
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      session_id: this.sessionId,
+      user_id: this.userId,
+      device: this.deviceInfo
+    });
+  }
+  /**
+   * Identify the current user
+   */
+  identify(userId, traits) {
+    if (!this.initialized) {
+      console.warn("[Luzzi] SDK not initialized. Call luzzi.init() first.");
+      return;
+    }
+    if (!userId || typeof userId !== "string") {
+      console.warn("[Luzzi] User ID is required and must be a string");
+      return;
+    }
+    this.userId = userId;
+    this.userTraits = { ...this.userTraits, ...traits };
+    this.log("User identified", { userId, traits });
+    this.track("$identify", {
+      ...this.userTraits,
+      $user_id: userId
+    });
+  }
+  /**
+   * Reset the current user (logout)
+   */
+  reset() {
+    this.log("Resetting user");
+    this.flush();
+    this.userId = void 0;
+    this.userTraits = {};
+    this.sessionId = this.generateSessionId();
+    this.log("Reset complete", { newSessionId: this.sessionId });
+  }
+  /**
+   * Manually flush the event queue
+   */
+  async flush() {
+    if (!this.initialized) {
+      return;
+    }
+    await this.queue.flush();
+  }
+  /**
+   * Get the current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Get the current user ID
+   */
+  getUserId() {
+    return this.userId;
+  }
+  /**
+   * Generate a unique session ID
+   */
+  generateSessionId() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+  }
+  /**
+   * Collect device information
+   */
+  collectDeviceInfo() {
+    const info = {};
+    if (typeof window !== "undefined" && typeof navigator !== "undefined") {
+      const ua = navigator.userAgent;
+      if (ua.includes("Windows")) info.os = "windows";
+      else if (ua.includes("Mac")) info.os = "macos";
+      else if (ua.includes("Linux")) info.os = "linux";
+      else if (ua.includes("Android")) info.os = "android";
+      else if (ua.includes("iPhone") || ua.includes("iPad")) info.os = "ios";
+      if (ua.includes("Chrome") && !ua.includes("Edg")) info.browser = "chrome";
+      else if (ua.includes("Firefox")) info.browser = "firefox";
+      else if (ua.includes("Safari") && !ua.includes("Chrome")) info.browser = "safari";
+      else if (ua.includes("Edg")) info.browser = "edge";
+      info.screen_width = window.screen?.width;
+      info.screen_height = window.screen?.height;
+      info.language = navigator.language;
+      try {
+        info.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      } catch {
+      }
+    }
+    if (typeof process !== "undefined" && process.versions?.node) {
+      info.os = process.platform;
+      info.app_version = process.versions.node;
+    }
+    return info;
+  }
+  /**
+   * Debug log
+   */
+  log(message, data) {
+    if (this.debug) {
+      console.log(`[Luzzi] ${message}`, data || "");
+    }
+  }
+};
+var luzziCore = new LuzziCore();
+
+// src/index.ts
+var luzzi = {
+  /**
+   * Initialize the SDK with your API key
+   * Must be called before any other method
+   *
+   * @param apiKey - Your Luzzi API key (pk_live_xxx or pk_test_xxx)
+   * @param config - Optional configuration
+   */
+  init: (apiKey, config) => {
+    luzziCore.init(apiKey, config);
+  },
+  /**
+   * Track an event
+   *
+   * @param eventName - Name of the event (e.g., "button_clicked", "page_viewed")
+   * @param properties - Optional event properties
+   *
+   * @example
+   * luzzi.track("purchase_completed", { amount: 99.99, currency: "USD" });
+   */
+  track: (eventName, properties) => {
+    luzziCore.track(eventName, properties);
+  },
+  /**
+   * Identify the current user
+   *
+   * @param userId - Unique user identifier
+   * @param traits - Optional user traits/properties
+   *
+   * @example
+   * luzzi.identify("user_123", { email: "user@example.com", plan: "pro" });
+   */
+  identify: (userId, traits) => {
+    luzziCore.identify(userId, traits);
+  },
+  /**
+   * Reset the current user (call on logout)
+   * Clears user ID and generates a new session
+   */
+  reset: () => {
+    luzziCore.reset();
+  },
+  /**
+   * Manually flush pending events to the server
+   * Events are automatically flushed on a timer and on page unload
+   */
+  flush: () => {
+    return luzziCore.flush();
+  },
+  /**
+   * Get the current session ID
+   */
+  getSessionId: () => {
+    return luzziCore.getSessionId();
+  },
+  /**
+   * Get the current user ID (if identified)
+   */
+  getUserId: () => {
+    return luzziCore.getUserId();
+  }
+};
+var index_default = luzzi;
+var { init, track, identify, reset, flush, getSessionId, getUserId } = luzzi;
+export {
+  index_default as default,
+  flush,
+  getSessionId,
+  getUserId,
+  identify,
+  init,
+  reset,
+  track
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "luzzi-analytics",
+    "version": "0.1.0",
+    "description": "Simple, plug-and-play analytics SDK for solo builders",
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "scripts": {
+        "build": "tsup src/index.ts --format cjs,esm --dts",
+        "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+        "clean": "rimraf dist"
+    },
+    "keywords": [
+        "analytics",
+        "tracking",
+        "events",
+        "solo-builder",
+        "luzzi"
+    ],
+    "author": "",
+    "license": "MIT",
+    "devDependencies": {
+        "tsup": "^8.0.0",
+        "typescript": "^5.0.0",
+        "rimraf": "^5.0.0"
+    },
+    "files": [
+        "dist"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/your-username/luzzi"
+    }
+}