@codmir/sdk 0.1.1

package/README.md

@@ -0,0 +1,206 @@
+# @codmir/sdk
+
+Official TypeScript/JavaScript SDK for the Codmir API.
+
+> **Note:** For CLI usage, install the `codmir` package instead: `npm install -g codmir`
+
+## Installation
+
+```bash
+npm install @codmir/sdk
+# or
+pnpm add @codmir/sdk
+# or
+yarn add @codmir/sdk
+```
+
+## Quick Start
+
+```typescript
+import { CodmirClient } from '@codmir/sdk';
+
+const client = new CodmirClient({
+  apiKey: process.env.CODMIR_API_KEY,
+});
+
+// List projects
+const projects = await client.listProjects();
+
+// Create a ticket
+const ticket = await client.createTicket({
+  title: 'Fix login bug',
+  description: 'Users cannot login with SSO',
+  type: 'bug',
+  priority: 'high',
+  projectId: 'project-123',
+});
+
+// Use AI chat
+const response = await client.chat('How do I implement OAuth2?');
+console.log(response);
+```
+
+## Configuration
+
+```typescript
+const client = new CodmirClient({
+  apiKey: 'your-api-key',      // Or set CODMIR_API_KEY env var
+  baseUrl: 'https://codmir.com/api',  // Optional, defaults to production
+  timeout: 30000,              // Request timeout in ms
+  headers: {                   // Custom headers
+    'X-Custom-Header': 'value',
+  },
+});
+```
+
+## API Reference
+
+### Authentication
+
+```typescript
+// Get current user
+const user = await client.whoami();
+```
+
+### Projects
+
+```typescript
+// List all projects
+const projects = await client.listProjects();
+
+// Get a specific project
+const project = await client.getProject('project-id');
+
+// Create a project
+const newProject = await client.createProject({
+  name: 'My Project',
+  organizationId: 'org-id',
+});
+```
+
+### Tickets
+
+```typescript
+// List tickets
+const tickets = await client.listTickets('project-id', {
+  page: 1,
+  pageSize: 20,
+  status: 'open',
+});
+
+// Get a ticket
+const ticket = await client.getTicket('project-id', 'ticket-id');
+
+// Create a ticket
+const ticket = await client.createTicket({
+  title: 'Bug report',
+  description: 'Something is broken',
+  type: 'bug',
+  priority: 'high',
+  projectId: 'project-id',
+});
+
+// Update a ticket
+const updated = await client.updateTicket('project-id', 'ticket-id', {
+  status: 'in_progress',
+});
+
+// Delete a ticket
+await client.deleteTicket('project-id', 'ticket-id');
+```
+
+### Test Cases
+
+```typescript
+// List test cases
+const testCases = await client.listTestCases('project-id');
+
+// Create a test case
+const testCase = await client.createTestCase({
+  title: 'Login flow',
+  projectId: 'project-id',
+  steps: [
+    { order: 1, action: 'Open login page', expectedResult: 'Login form displayed' },
+    { order: 2, action: 'Enter credentials', expectedResult: 'Fields populated' },
+    { order: 3, action: 'Click submit', expectedResult: 'User logged in' },
+  ],
+});
+```
+
+### AI Agent Tasks
+
+```typescript
+// Create an agent task
+const task = await client.createAgentTask({
+  type: 'code_review',
+  prompt: 'Review this pull request for security issues',
+  projectId: 'project-id',
+});
+
+// Run the task
+const execution = await client.runAgentTask({
+  taskId: task.id,
+  options: {
+    model: 'gpt-4-turbo',
+  },
+});
+
+// Get task status
+const status = await client.getAgentTask(task.id);
+```
+
+### AI Chat
+
+```typescript
+// Simple chat
+const response = await client.chat('Explain dependency injection');
+
+// Chat with project context
+const response = await client.chat('How is auth implemented?', {
+  projectId: 'project-id',
+});
+
+// Streaming chat
+const fullResponse = await client.streamChat('Write a function to...', {
+  onChunk: (chunk) => process.stdout.write(chunk),
+});
+```
+
+## Error Handling
+
+```typescript
+import { CodmirClient, CodmirApiError } from '@codmir/sdk';
+
+try {
+  const ticket = await client.getTicket('project-id', 'invalid-id');
+} catch (error) {
+  if (error instanceof CodmirApiError) {
+    console.error(`API Error: ${error.code} - ${error.message}`);
+    console.error(`Status: ${error.statusCode}`);
+  }
+}
+```
+
+## TypeScript Support
+
+Full TypeScript support with exported types:
+
+```typescript
+import type {
+  Ticket,
+  CreateTicketInput,
+  TicketStatus,
+  TicketPriority,
+  AgentTask,
+  AgentTaskType,
+} from '@codmir/sdk';
+```
+
+## Related Packages
+
+- `codmir` - CLI tool for terminal usage
+- `@codmir/types` - Shared type definitions
+
+## License
+
+MIT

package/dist/browser/index.cjs

@@ -0,0 +1,409 @@
+"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/browser/index.ts
+var browser_exports = {};
+__export(browser_exports, {
+  addBreadcrumb: () => addBreadcrumb,
+  captureException: () => captureException,
+  captureMessage: () => captureMessage,
+  close: () => close,
+  flush: () => flush,
+  getClient: () => getClient,
+  init: () => init2,
+  isOverseerInitialized: () => isOverseerInitialized,
+  setTags: () => setTags,
+  setUser: () => setUser
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/overseer/index.ts
+var import_nanoid = require("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 = (0, import_nanoid.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 = (0, import_nanoid.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 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();
+}
+
+// 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addBreadcrumb,
+  captureException,
+  captureMessage,
+  close,
+  flush,
+  getClient,
+  init,
+  isOverseerInitialized,
+  setTags,
+  setUser
+});

package/dist/browser/index.d.cts

@@ -0,0 +1,47 @@
+import { O as OverseerConfig } from '../index-BlgYnCLd.cjs';
+export { B as Breadcrumb, S as SeverityLevel, U as UserContext, d as addBreadcrumb, c as captureException, a as captureMessage, e as close, f as flush, g as getClient, b as setTags, s as setUser } from '../index-BlgYnCLd.cjs';
+
+/**
+ * @codmir/sdk/browser - Browser-Only Integration
+ *
+ * Lightweight error tracking for vanilla JavaScript/TypeScript
+ * browser applications.
+ *
+ * @example
+ * ```html
+ * <script type="module">
+ *   import { init, captureException } from '@codmir/sdk/browser';
+ *
+ *   init({
+ *     dsn: 'https://your-project.codmir.com/api/overseer',
+ *   });
+ *
+ *   window.onerror = (msg, url, line, col, error) => {
+ *     captureException(error);
+ *   };
+ * </script>
+ * ```
+ */
+
+interface BrowserConfig extends OverseerConfig {
+    /** Automatically capture global errors */
+    captureGlobalErrors?: boolean;
+    /** Automatically capture unhandled promise rejections */
+    captureUnhandledRejections?: boolean;
+    /** Automatically capture console.error */
+    captureConsoleErrors?: boolean;
+    /** Track user clicks as breadcrumbs */
+    trackClicks?: boolean;
+    /** Track user inputs as breadcrumbs (values are masked) */
+    trackInputs?: boolean;
+    /** Track XHR/fetch requests as breadcrumbs */
+    trackRequests?: boolean;
+}
+declare function init(config?: BrowserConfig): void;
+
+/**
+ * Check if Overseer is initialized
+ */
+declare function isOverseerInitialized(): boolean;
+
+export { type BrowserConfig, OverseerConfig, init, isOverseerInitialized };

package/dist/browser/index.d.ts

@@ -0,0 +1,47 @@
+import { O as OverseerConfig } from '../index-BlgYnCLd.js';
+export { B as Breadcrumb, S as SeverityLevel, U as UserContext, d as addBreadcrumb, c as captureException, a as captureMessage, e as close, f as flush, g as getClient, b as setTags, s as setUser } from '../index-BlgYnCLd.js';
+
+/**
+ * @codmir/sdk/browser - Browser-Only Integration
+ *
+ * Lightweight error tracking for vanilla JavaScript/TypeScript
+ * browser applications.
+ *
+ * @example
+ * ```html
+ * <script type="module">
+ *   import { init, captureException } from '@codmir/sdk/browser';
+ *
+ *   init({
+ *     dsn: 'https://your-project.codmir.com/api/overseer',
+ *   });
+ *
+ *   window.onerror = (msg, url, line, col, error) => {
+ *     captureException(error);
+ *   };
+ * </script>
+ * ```
+ */
+
+interface BrowserConfig extends OverseerConfig {
+    /** Automatically capture global errors */
+    captureGlobalErrors?: boolean;
+    /** Automatically capture unhandled promise rejections */
+    captureUnhandledRejections?: boolean;
+    /** Automatically capture console.error */
+    captureConsoleErrors?: boolean;
+    /** Track user clicks as breadcrumbs */
+    trackClicks?: boolean;
+    /** Track user inputs as breadcrumbs (values are masked) */
+    trackInputs?: boolean;
+    /** Track XHR/fetch requests as breadcrumbs */
+    trackRequests?: boolean;
+}
+declare function init(config?: BrowserConfig): void;
+
+/**
+ * Check if Overseer is initialized
+ */
+declare function isOverseerInitialized(): boolean;
+
+export { type BrowserConfig, OverseerConfig, init, isOverseerInitialized };