@codmir/sdk 0.1.1

package/dist/browser/index.js

@@ -0,0 +1,186 @@
+import {
+  addBreadcrumb,
+  captureException,
+  captureMessage,
+  close,
+  flush,
+  getClient,
+  init,
+  setTags,
+  setUser
+} from "../chunk-T7OAAOG2.js";
+import "../chunk-MLKGABMK.js";
+
+// src/browser/index.ts
+var isInitialized = false;
+function init2(config = {}) {
+  if (typeof window === "undefined") {
+    console.warn("[@codmir/sdk/browser] Cannot initialize in non-browser environment");
+    return;
+  }
+  if (isInitialized) return;
+  const {
+    captureGlobalErrors = true,
+    captureUnhandledRejections = true,
+    captureConsoleErrors = false,
+    trackClicks = true,
+    trackInputs = false,
+    trackRequests = true,
+    ...coreConfig
+  } = config;
+  init(coreConfig);
+  isInitialized = true;
+  if (captureGlobalErrors) {
+    window.addEventListener("error", (event) => {
+      captureException(event.error || event.message, {
+        handled: false,
+        mechanism: "onerror",
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno
+      });
+    });
+  }
+  if (captureUnhandledRejections) {
+    window.addEventListener("unhandledrejection", (event) => {
+      captureException(event.reason, {
+        handled: false,
+        mechanism: "onunhandledrejection"
+      });
+    });
+  }
+  if (captureConsoleErrors) {
+    const originalError = console.error;
+    console.error = (...args) => {
+      captureMessage(args.map(String).join(" "), "error");
+      originalError.apply(console, args);
+    };
+  }
+  if (trackClicks) {
+    document.addEventListener("click", (event) => {
+      const target = event.target;
+      if (!target) return;
+      const breadcrumb = {
+        category: "ui.click",
+        message: getElementDescription(target),
+        data: {
+          tag: target.tagName.toLowerCase(),
+          id: target.id || void 0,
+          class: target.className || void 0
+        }
+      };
+      addBreadcrumb(breadcrumb);
+    });
+  }
+  if (trackInputs) {
+    document.addEventListener("input", (event) => {
+      const target = event.target;
+      if (!target) return;
+      const breadcrumb = {
+        category: "ui.input",
+        message: getElementDescription(target),
+        data: {
+          tag: target.tagName.toLowerCase(),
+          type: target.type || "text"
+          // Never log actual values
+        }
+      };
+      addBreadcrumb(breadcrumb);
+    });
+  }
+  if (trackRequests) {
+    setupRequestTracking();
+  }
+}
+function getElementDescription(el) {
+  let description = el.tagName.toLowerCase();
+  if (el.id) {
+    description += `#${el.id}`;
+  } else if (el.className) {
+    description += `.${el.className.split(" ")[0]}`;
+  }
+  if (el.tagName === "BUTTON" || el.tagName === "A") {
+    const text = el.textContent?.trim().slice(0, 50);
+    if (text) {
+      description += ` "${text}"`;
+    }
+  }
+  return description;
+}
+function setupRequestTracking() {
+  const originalFetch = window.fetch;
+  window.fetch = async function(input, init3) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const method = init3?.method || "GET";
+    const startTime = Date.now();
+    try {
+      const response = await originalFetch.call(window, input, init3);
+      addBreadcrumb({
+        category: "fetch",
+        message: `${method} ${url}`,
+        data: {
+          method,
+          url,
+          status: response.status,
+          duration: Date.now() - startTime
+        },
+        level: response.ok ? "info" : "error"
+      });
+      return response;
+    } catch (error) {
+      addBreadcrumb({
+        category: "fetch",
+        message: `${method} ${url}`,
+        data: {
+          method,
+          url,
+          error: error instanceof Error ? error.message : "Network error",
+          duration: Date.now() - startTime
+        },
+        level: "error"
+      });
+      throw error;
+    }
+  };
+  const originalXHROpen = XMLHttpRequest.prototype.open;
+  const originalXHRSend = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.open = function(method, url) {
+    this.__codmir = { method, url: url.toString(), startTime: 0 };
+    return originalXHROpen.apply(this, arguments);
+  };
+  XMLHttpRequest.prototype.send = function(body) {
+    const data = this.__codmir;
+    if (data) {
+      data.startTime = Date.now();
+      this.addEventListener("loadend", () => {
+        addBreadcrumb({
+          category: "xhr",
+          message: `${data.method} ${data.url}`,
+          data: {
+            method: data.method,
+            url: data.url,
+            status: this.status,
+            duration: Date.now() - data.startTime
+          },
+          level: this.status >= 400 ? "error" : "info"
+        });
+      });
+    }
+    return originalXHRSend.call(this, body);
+  };
+}
+function isOverseerInitialized() {
+  return isInitialized && getClient() !== null;
+}
+export {
+  addBreadcrumb,
+  captureException,
+  captureMessage,
+  close,
+  flush,
+  getClient,
+  init2 as init,
+  isOverseerInitialized,
+  setTags,
+  setUser
+};

package/dist/chunk-233XBWQD.js

@@ -0,0 +1,43 @@
+// src/types.ts
+import { z } from "zod";
+var CodmirApiError = class extends Error {
+  constructor(code, message, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "CodmirApiError";
+  }
+};
+var CreateTicketSchema = z.object({
+  title: z.string().min(1).max(200),
+  description: z.string().optional(),
+  status: z.enum(["open", "in_progress", "review", "done", "closed"]).optional(),
+  priority: z.enum(["low", "medium", "high", "critical"]).optional(),
+  type: z.enum(["bug", "feature", "task", "improvement", "epic"]).optional(),
+  projectId: z.string().uuid(),
+  assigneeId: z.string().uuid().optional(),
+  labels: z.array(z.string()).optional(),
+  dueDate: z.string().datetime().optional()
+});
+var CreateAgentTaskSchema = z.object({
+  type: z.enum([
+    "code_review",
+    "bug_fix",
+    "feature_implementation",
+    "refactor",
+    "documentation",
+    "test_generation",
+    "analysis",
+    "custom"
+  ]),
+  prompt: z.string().min(1),
+  context: z.record(z.unknown()).optional(),
+  projectId: z.string().uuid().optional()
+});
+
+export {
+  CodmirApiError,
+  CreateTicketSchema,
+  CreateAgentTaskSchema
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-T7OAAOG2.js

@@ -0,0 +1,235 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/overseer/index.ts
+var overseer_exports = {};
+__export(overseer_exports, {
+  OverseerClient: () => OverseerClient,
+  addBreadcrumb: () => addBreadcrumb,
+  captureException: () => captureException,
+  captureMessage: () => captureMessage,
+  close: () => close,
+  flush: () => flush,
+  getClient: () => getClient,
+  init: () => init,
+  setTag: () => setTag,
+  setTags: () => setTags,
+  setUser: () => setUser
+});
+import { nanoid } from "nanoid";
+var OverseerClient = class {
+  config;
+  user = null;
+  tags = {};
+  breadcrumbs = [];
+  eventQueue = [];
+  flushTimer = null;
+  isInitialized = false;
+  constructor(config = {}) {
+    this.config = {
+      dsn: config.dsn || "",
+      environment: config.environment || "development",
+      release: config.release || "unknown",
+      enabled: config.enabled ?? true,
+      debug: config.debug ?? false,
+      sampleRate: config.sampleRate ?? 1,
+      tracesSampleRate: config.tracesSampleRate ?? 0,
+      replaysSessionSampleRate: config.replaysSessionSampleRate ?? 0,
+      replaysOnErrorSampleRate: config.replaysOnErrorSampleRate ?? 1,
+      beforeSend: config.beforeSend || ((e) => e),
+      initialUser: config.initialUser,
+      initialTags: config.initialTags || {}
+    };
+    if (this.config.initialUser) {
+      this.user = this.config.initialUser;
+    }
+    if (this.config.initialTags) {
+      this.tags = { ...this.config.initialTags };
+    }
+  }
+  init() {
+    if (this.isInitialized) return;
+    this.isInitialized = true;
+    if (this.config.debug) {
+      console.log("[Overseer] Initialized", {
+        dsn: this.config.dsn,
+        environment: this.config.environment
+      });
+    }
+  }
+  captureException(error, context) {
+    if (!this.config.enabled) return "";
+    if (!this.shouldSample(this.config.sampleRate)) return "";
+    const eventId = nanoid();
+    const err = error instanceof Error ? error : new Error(String(error));
+    const event = {
+      id: eventId,
+      type: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "error",
+      message: err.message,
+      exception: {
+        type: err.name,
+        value: err.message,
+        stacktrace: this.parseStackTrace(err.stack),
+        mechanism: { type: "generic", handled: true }
+      },
+      user: this.user || void 0,
+      tags: { ...this.tags },
+      extra: context,
+      breadcrumbs: [...this.breadcrumbs],
+      environment: this.config.environment,
+      release: this.config.release,
+      sdk: { name: "@codmir/sdk", version: "1.0.0" }
+    };
+    this.sendEvent(event);
+    return eventId;
+  }
+  captureMessage(message, level = "info") {
+    if (!this.config.enabled) return "";
+    if (!this.shouldSample(this.config.sampleRate)) return "";
+    const eventId = nanoid();
+    const event = {
+      id: eventId,
+      type: "message",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      user: this.user || void 0,
+      tags: { ...this.tags },
+      breadcrumbs: [...this.breadcrumbs],
+      environment: this.config.environment,
+      release: this.config.release,
+      sdk: { name: "@codmir/sdk", version: "1.0.0" }
+    };
+    this.sendEvent(event);
+    return eventId;
+  }
+  setUser(user) {
+    this.user = user;
+  }
+  setTag(key, value) {
+    this.tags[key] = value;
+  }
+  setTags(tags) {
+    this.tags = { ...this.tags, ...tags };
+  }
+  setExtra(key, value) {
+  }
+  addBreadcrumb(breadcrumb) {
+    this.breadcrumbs.push({
+      ...breadcrumb,
+      timestamp: breadcrumb.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.breadcrumbs.length > 100) {
+      this.breadcrumbs = this.breadcrumbs.slice(-100);
+    }
+  }
+  async flush(timeout) {
+    if (this.eventQueue.length === 0) return true;
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    try {
+      await this.sendBatch(events);
+      return true;
+    } catch {
+      this.eventQueue.unshift(...events);
+      return false;
+    }
+  }
+  close() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flush();
+  }
+  // Private methods
+  shouldSample(rate) {
+    return Math.random() < rate;
+  }
+  parseStackTrace(stack) {
+    if (!stack) return [];
+    return stack.split("\n").slice(1).map((line) => {
+      const match = line.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
+      if (match) {
+        return {
+          function: match[1],
+          filename: match[2],
+          lineno: parseInt(match[3], 10),
+          colno: parseInt(match[4], 10),
+          in_app: !match[2].includes("node_modules")
+        };
+      }
+      return { function: line.trim() };
+    }).filter((f) => f.function);
+  }
+  sendEvent(event) {
+    const processed = this.config.beforeSend(event);
+    if (!processed) return;
+    this.eventQueue.push(processed);
+    if (this.flushTimer) clearTimeout(this.flushTimer);
+    this.flushTimer = setTimeout(() => this.flush(), 1e3);
+  }
+  async sendBatch(events) {
+    if (!this.config.dsn) {
+      if (this.config.debug) {
+        console.log("[Overseer] No DSN configured, events:", events);
+      }
+      return;
+    }
+    const endpoint = this.config.dsn.endsWith("/ingest") ? this.config.dsn : `${this.config.dsn}/ingest`;
+    await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ events })
+    });
+  }
+};
+var client = null;
+function init(config = {}) {
+  client = new OverseerClient(config);
+  client.init();
+}
+function getClient() {
+  return client;
+}
+function captureException(error, context) {
+  return client?.captureException(error, context) || "";
+}
+function captureMessage(message, level) {
+  return client?.captureMessage(message, level) || "";
+}
+function setUser(user) {
+  client?.setUser(user);
+}
+function setTag(key, value) {
+  client?.setTag(key, value);
+}
+function setTags(tags) {
+  client?.setTags(tags);
+}
+function addBreadcrumb(breadcrumb) {
+  client?.addBreadcrumb(breadcrumb);
+}
+function flush(timeout) {
+  return client?.flush(timeout) || Promise.resolve(true);
+}
+function close() {
+  client?.close();
+}
+
+export {
+  OverseerClient,
+  init,
+  getClient,
+  captureException,
+  captureMessage,
+  setUser,
+  setTag,
+  setTags,
+  addBreadcrumb,
+  flush,
+  close,
+  overseer_exports
+};