@sigsentry/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SigSentry
+
+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,48 @@
+# @sigsentry/core
+
+TypeScript API client and shared types for [SigSentry](https://sigsentry.dev) — AI-powered log analysis.
+
+## Installation
+
+```bash
+npm install @sigsentry/core
+```
+
+## Quick Start
+
+```typescript
+import { SigSentryClient } from '@sigsentry/core';
+
+const client = new SigSentryClient({
+  apiKey: 'your-api-key',
+});
+
+// Create an analysis
+const result = await client.createAnalysis({
+  description: 'Users getting 500 errors on checkout',
+  timeStart: new Date('2024-01-15T10:00:00Z'),
+  timeEnd: new Date('2024-01-15T11:00:00Z'),
+});
+
+// Stream results in real-time
+await client.createAnalysis(input, {
+  onStatus: (stage) => console.log(`Stage: ${stage}`),
+  onPartial: (partial) => console.log(`Severity: ${partial.severity}`),
+  onComplete: (id, result) => console.log(`Done: ${result.summary}`),
+});
+```
+
+## What's Included
+
+- **SigSentryClient** — Framework-agnostic API client with SSE streaming
+- **TypeScript types** — AnalysisResult, AnalysisInput, ApiResponse, and more
+- **Result<T, E>** — Type-safe error handling without exceptions
+- **ErrorCode** — Standardized error codes
+
+## For React
+
+See [@sigsentry/react](https://www.npmjs.com/package/@sigsentry/react) for drop-in React components.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,458 @@
+type AnalysisSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
+type AnalysisStatus = 'pending' | 'processing' | 'complete' | 'partial' | 'failed';
+interface AnalysisInput {
+    screenshot?: File | Buffer;
+    description: string;
+    timeStart: Date;
+    timeEnd: Date;
+    metadata?: Record<string, string>;
+}
+interface AnalysisResult {
+    id: string;
+    status: AnalysisStatus;
+    createdAt: Date;
+    summary: string;
+    severity: AnalysisSeverity;
+    confidence: number;
+    rootCause: {
+        description: string;
+        service: string;
+        errorType: string;
+        category: ErrorCategory;
+    };
+    affectedServices: ServiceImpact[];
+    timeline: TimelineEntry[];
+    logEvidence: LogEvidence[];
+    codeCorrelation?: {
+        available: boolean;
+        suspectedCode: {
+            repo: string;
+            filePath: string;
+            lineRange: [number, number];
+            functionName: string;
+            snippet: string;
+        };
+        causalPR?: {
+            id: string;
+            title: string;
+            author: {
+                name: string;
+                username: string;
+            };
+            mergedAt: Date;
+            url: string;
+            confidence: number;
+            explanation: string;
+        };
+        recentCommits: CommitRef[];
+    };
+    suggestedActions: SuggestedAction[];
+    relatedIncidents: string[];
+    logsScanned: number;
+    timeWindow: {
+        start: Date;
+        end: Date;
+    };
+    processingTimeMs: number;
+}
+type ErrorCategory = 'authentication' | 'authorization' | 'database' | 'network' | 'timeout' | 'rate_limiting' | 'validation' | 'null_reference' | 'configuration' | 'dependency' | 'memory' | 'disk' | 'unknown';
+interface ServiceImpact {
+    serviceName: string;
+    role: 'origin' | 'propagator' | 'affected';
+    errorCount: number;
+    firstSeen: Date;
+    lastSeen: Date;
+}
+interface TimelineEntry {
+    timestamp: Date;
+    service: string;
+    level: 'error' | 'warn' | 'info';
+    message: string;
+    isRootCause: boolean;
+}
+interface LogEvidence {
+    timestamp: Date;
+    service: string;
+    level: string;
+    message: string;
+    raw: string;
+    relevanceScore: number;
+}
+interface SuggestedAction {
+    priority: number;
+    action: string;
+    rationale: string;
+    type: 'fix' | 'investigate' | 'mitigate' | 'escalate';
+}
+interface CommitRef {
+    sha: string;
+    message: string;
+    author: string;
+    date: Date;
+    filesChanged: string[];
+}
+interface FollowUpInput {
+    analysisId: string;
+    question: string;
+}
+interface FollowUpResult {
+    analysisId: string;
+    answer: string;
+    additionalEvidence?: LogEvidence[];
+    updatedSuggestedActions?: SuggestedAction[];
+}
+interface AnalysisFeedback {
+    analysisId: string;
+    accuracy: 'correct' | 'partially_correct' | 'incorrect';
+    comment?: string;
+}
+
+interface LogSourceAdapter {
+    testConnection(config: LogSourceConfig): Promise<ConnectionResult>;
+    queryLogs(params: LogQuery): Promise<LogResult>;
+    listSources(config: LogSourceConfig): Promise<LogSourceInfo[]>;
+    metadata: AdapterMetadata;
+}
+interface LogSourceConfig {
+    type: LogSourceType;
+    credentials: Record<string, string>;
+    region?: string;
+    settings?: Record<string, unknown>;
+}
+type LogSourceType = 'cloudwatch' | 'datadog' | 'elastic' | 'loki' | 'splunk' | 'gcp_logging';
+interface LogQuery {
+    timeRange: {
+        start: Date;
+        end: Date;
+    };
+    sources: string[];
+    filters?: LogFilter[];
+    limit?: number;
+    cursor?: string;
+}
+interface LogFilter {
+    field: string;
+    operator: 'eq' | 'contains' | 'regex' | 'gt' | 'lt';
+    value: string;
+}
+interface LogResult {
+    entries: LogEntry[];
+    totalCount: number;
+    nextCursor?: string;
+    truncated: boolean;
+}
+interface LogEntry {
+    timestamp: Date;
+    level: string;
+    service: string;
+    message: string;
+    raw: string;
+    metadata?: Record<string, string>;
+}
+interface LogSourceInfo {
+    id: string;
+    name: string;
+    type: string;
+}
+interface ConnectionResult {
+    success: boolean;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface AdapterMetadata {
+    type: LogSourceType;
+    displayName: string;
+    description: string;
+    requiredCredentials: CredentialField[];
+    supportedFeatures: string[];
+}
+interface CredentialField {
+    key: string;
+    label: string;
+    type: 'text' | 'password' | 'select';
+    required: boolean;
+    placeholder?: string;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+}
+interface CodeRepoAdapter {
+    testConnection(config: RepoConfig): Promise<ConnectionResult>;
+    getFileContent(params: {
+        repo: string;
+        path: string;
+        ref?: string;
+    }): Promise<FileContent>;
+    getBlame(params: {
+        repo: string;
+        path: string;
+        ref?: string;
+        lineStart?: number;
+        lineEnd?: number;
+    }): Promise<BlameResult[]>;
+    findPullRequests(params: {
+        repo: string;
+        paths: string[];
+        mergedAfter: Date;
+        mergedBefore: Date;
+    }): Promise<PullRequestInfo[]>;
+    getPullRequestDiff(params: {
+        repo: string;
+        prId: string;
+        filePaths?: string[];
+    }): Promise<DiffResult>;
+    listRepositories(config: RepoConfig): Promise<RepositoryInfo[]>;
+}
+interface RepoConfig {
+    platform: RepoPlatform;
+    credentials: Record<string, string>;
+    baseUrl?: string;
+}
+type RepoPlatform = 'github' | 'gitlab' | 'bitbucket' | 'azure_devops';
+interface FileContent {
+    path: string;
+    content: string;
+    encoding: 'utf8' | 'base64';
+    sha: string;
+    size: number;
+}
+interface BlameResult {
+    lineStart: number;
+    lineEnd: number;
+    commit: {
+        sha: string;
+        author: string;
+        date: Date;
+        message: string;
+    };
+}
+interface PullRequestInfo {
+    id: string;
+    title: string;
+    author: {
+        name: string;
+        username: string;
+        avatar?: string;
+    };
+    mergedAt: Date;
+    url: string;
+    filesChanged: string[];
+    additions: number;
+    deletions: number;
+}
+interface DiffResult {
+    prId: string;
+    files: FileDiff[];
+}
+interface FileDiff {
+    path: string;
+    additions: number;
+    deletions: number;
+    patch: string;
+}
+interface RepositoryInfo {
+    id: string;
+    name: string;
+    fullName: string;
+    defaultBranch: string;
+    url: string;
+    private: boolean;
+}
+interface ServiceRepoMapping {
+    serviceName: string;
+    repo: string;
+    pathPrefix: string;
+    defaultBranch: string;
+}
+
+interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: ApiError;
+}
+interface ApiError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface CreateAnalysisRequest {
+    description: string;
+    timeStart: string;
+    timeEnd: string;
+    metadata?: Record<string, string>;
+}
+interface ListAnalysesQuery {
+    page?: number;
+    limit?: number;
+    status?: AnalysisStatus;
+    severity?: AnalysisSeverity;
+    fromDate?: string;
+    toDate?: string;
+}
+interface FollowUpRequest {
+    question: string;
+}
+interface FeedbackRequest {
+    accuracy: 'correct' | 'partially_correct' | 'incorrect';
+    comment?: string;
+}
+type SSEEvent = {
+    event: 'status';
+    data: {
+        stage: AnalysisStage;
+        detail?: string;
+    };
+} | {
+    event: 'partial';
+    data: Partial<AnalysisResult>;
+} | {
+    event: 'complete';
+    data: {
+        analysisId: string;
+        result: AnalysisResult;
+    };
+} | {
+    event: 'error';
+    data: {
+        code: string;
+        message: string;
+    };
+};
+type AnalysisStage = 'input_received' | 'image_processing' | 'logs_fetching' | 'logs_preprocessing' | 'ai_analyzing' | 'code_correlating' | 'complete' | 'failed';
+
+interface Tenant {
+    id: string;
+    name: string;
+    plan: PricingTier;
+    createdAt: Date;
+    settings: TenantSettings;
+}
+type PricingTier = 'starter' | 'team' | 'business' | 'enterprise';
+interface TenantSettings {
+    timeBufferMinutes: number;
+    maxAnalysesPerMonth: number;
+    enabledFeatures: FeatureFlag[];
+    defaultLogSources: string[];
+}
+type FeatureFlag = 'code_correlation' | 'pattern_memory' | 'slack_integration' | 'teams_integration' | 'sso' | 'custom_llm' | 'self_hosted' | 'audit_logs';
+interface ApiKeyRecord {
+    id: string;
+    tenantId: string;
+    keyHash: string;
+    prefix: string;
+    name: string;
+    permissions: ApiKeyPermission[];
+    createdAt: Date;
+    lastUsedAt?: Date;
+    expiresAt?: Date;
+    revoked: boolean;
+}
+type ApiKeyPermission = 'analysis:create' | 'analysis:read' | 'config:read' | 'config:write' | 'admin';
+interface LogSourceConfigRecord {
+    id: string;
+    tenantId: string;
+    type: LogSourceType;
+    name: string;
+    credentials: string;
+    sources: string[];
+    isActive: boolean;
+    lastTestedAt?: Date;
+    lastTestResult?: ConnectionResult;
+    createdAt: Date;
+}
+interface RepoConfigRecord {
+    id: string;
+    tenantId: string;
+    platform: RepoPlatform;
+    credentials: string;
+    repositories: string[];
+    serviceMappings: ServiceRepoMapping[];
+    lookbackDays: number;
+    isActive: boolean;
+    createdAt: Date;
+}
+
+type Result<T, E = Error> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+declare function ok<T>(value: T): Result<T, never>;
+declare function err<E>(error: E): Result<never, E>;
+declare function isOk<T, E>(result: Result<T, E>): result is {
+    ok: true;
+    value: T;
+};
+declare function isErr<T, E>(result: Result<T, E>): result is {
+    ok: false;
+    error: E;
+};
+
+declare enum ErrorCode {
+    UNAUTHORIZED = "UNAUTHORIZED",
+    FORBIDDEN = "FORBIDDEN",
+    API_KEY_INVALID = "API_KEY_INVALID",
+    API_KEY_EXPIRED = "API_KEY_EXPIRED",
+    API_KEY_REVOKED = "API_KEY_REVOKED",
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    ANALYSIS_QUOTA_EXCEEDED = "ANALYSIS_QUOTA_EXCEEDED",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    INVALID_TIME_RANGE = "INVALID_TIME_RANGE",
+    FILE_TOO_LARGE = "FILE_TOO_LARGE",
+    LOG_SOURCE_CONNECTION_FAILED = "LOG_SOURCE_CONNECTION_FAILED",
+    LOG_SOURCE_QUERY_FAILED = "LOG_SOURCE_QUERY_FAILED",
+    LOG_SOURCE_NOT_CONFIGURED = "LOG_SOURCE_NOT_CONFIGURED",
+    REPO_CONNECTION_FAILED = "REPO_CONNECTION_FAILED",
+    REPO_NOT_CONFIGURED = "REPO_NOT_CONFIGURED",
+    REPO_FILE_NOT_FOUND = "REPO_FILE_NOT_FOUND",
+    FEATURE_NOT_AVAILABLE = "FEATURE_NOT_AVAILABLE",
+    ANALYSIS_NOT_FOUND = "ANALYSIS_NOT_FOUND",
+    ANALYSIS_FAILED = "ANALYSIS_FAILED",
+    LLM_ERROR = "LLM_ERROR",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    NOT_FOUND = "NOT_FOUND",
+    TENANT_NOT_FOUND = "TENANT_NOT_FOUND"
+}
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+declare function createLogger(service: string, minLevel?: LogLevel): {
+    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;
+};
+type Logger = ReturnType<typeof createLogger>;
+
+interface SigSentryClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+interface AnalysisStreamCallbacks {
+    onStatus?: (stage: AnalysisStage, detail?: string) => void;
+    onPartial?: (partial: Partial<AnalysisResult>) => void;
+    onComplete?: (analysisId: string, result: AnalysisResult) => void;
+    onError?: (error: ApiError) => void;
+}
+declare class SigSentryClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(config: SigSentryClientConfig);
+    private headers;
+    private request;
+    createAnalysis(input: Omit<AnalysisInput, 'screenshot'> & {
+        screenshot?: File;
+    }, callbacks?: AnalysisStreamCallbacks): Promise<ApiResponse<{
+        analysisId: string;
+        result: AnalysisResult;
+    }>>;
+    private handleSSEStream;
+    getAnalysis(id: string): Promise<ApiResponse<AnalysisResult>>;
+    listAnalyses(query?: ListAnalysesQuery): Promise<ApiResponse<AnalysisResult[]>>;
+    askFollowUp(analysisId: string, question: string): Promise<ApiResponse<FollowUpResult>>;
+    submitFeedback(analysisId: string, feedback: Omit<AnalysisFeedback, 'analysisId'>): Promise<ApiResponse<void>>;
+}
+
+export { type AdapterMetadata, type AnalysisFeedback, type AnalysisInput, type AnalysisResult, type AnalysisSeverity, type AnalysisStage, type AnalysisStatus, type AnalysisStreamCallbacks, type ApiError, type ApiKeyPermission, type ApiKeyRecord, type ApiResponse, type BlameResult, type CodeRepoAdapter, type CommitRef, type ConnectionResult, type CreateAnalysisRequest, type CredentialField, type DiffResult, type ErrorCategory, ErrorCode, type FeatureFlag, type FeedbackRequest, type FileContent, type FileDiff, type FollowUpInput, type FollowUpRequest, type FollowUpResult, type ListAnalysesQuery, type LogEntry, type LogEvidence, type LogFilter, type LogQuery, type LogResult, type LogSourceAdapter, type LogSourceConfig, type LogSourceConfigRecord, type LogSourceInfo, type LogSourceType, type Logger, type PricingTier, type PullRequestInfo, type RepoConfig, type RepoConfigRecord, type RepoPlatform, type RepositoryInfo, type Result, type SSEEvent, type ServiceImpact, type ServiceRepoMapping, SigSentryClient, type SigSentryClientConfig, type SuggestedAction, type Tenant, type TenantSettings, type TimelineEntry, createLogger, err, isErr, isOk, ok };

package/dist/index.js

@@ -0,0 +1,193 @@
+// src/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok;
+}
+function isErr(result) {
+  return !result.ok;
+}
+
+// src/errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  ErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  ErrorCode2["API_KEY_INVALID"] = "API_KEY_INVALID";
+  ErrorCode2["API_KEY_EXPIRED"] = "API_KEY_EXPIRED";
+  ErrorCode2["API_KEY_REVOKED"] = "API_KEY_REVOKED";
+  ErrorCode2["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+  ErrorCode2["ANALYSIS_QUOTA_EXCEEDED"] = "ANALYSIS_QUOTA_EXCEEDED";
+  ErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  ErrorCode2["INVALID_TIME_RANGE"] = "INVALID_TIME_RANGE";
+  ErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
+  ErrorCode2["LOG_SOURCE_CONNECTION_FAILED"] = "LOG_SOURCE_CONNECTION_FAILED";
+  ErrorCode2["LOG_SOURCE_QUERY_FAILED"] = "LOG_SOURCE_QUERY_FAILED";
+  ErrorCode2["LOG_SOURCE_NOT_CONFIGURED"] = "LOG_SOURCE_NOT_CONFIGURED";
+  ErrorCode2["REPO_CONNECTION_FAILED"] = "REPO_CONNECTION_FAILED";
+  ErrorCode2["REPO_NOT_CONFIGURED"] = "REPO_NOT_CONFIGURED";
+  ErrorCode2["REPO_FILE_NOT_FOUND"] = "REPO_FILE_NOT_FOUND";
+  ErrorCode2["FEATURE_NOT_AVAILABLE"] = "FEATURE_NOT_AVAILABLE";
+  ErrorCode2["ANALYSIS_NOT_FOUND"] = "ANALYSIS_NOT_FOUND";
+  ErrorCode2["ANALYSIS_FAILED"] = "ANALYSIS_FAILED";
+  ErrorCode2["LLM_ERROR"] = "LLM_ERROR";
+  ErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  ErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  ErrorCode2["TENANT_NOT_FOUND"] = "TENANT_NOT_FOUND";
+  return ErrorCode2;
+})(ErrorCode || {});
+
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function createLogger(service, minLevel = "info") {
+  const minLevelNum = LOG_LEVELS[minLevel];
+  function log(level, message, context) {
+    if (LOG_LEVELS[level] < minLevelNum) return;
+    const entry = {
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      context: { service, ...context }
+    };
+    const output = JSON.stringify(entry);
+    if (level === "error") {
+      process.stderr.write(output + "\n");
+    } else {
+      process.stdout.write(output + "\n");
+    }
+  }
+  return {
+    debug: (message, context) => log("debug", message, context),
+    info: (message, context) => log("info", message, context),
+    warn: (message, context) => log("warn", message, context),
+    error: (message, context) => log("error", message, context)
+  };
+}
+
+// src/client/index.ts
+var SigSentryClient = class {
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? "https://api.sigsentry.dev").replace(/\/$/, "");
+  }
+  headers() {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async request(method, path, body) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: this.headers(),
+      body: body ? JSON.stringify(body) : void 0
+    });
+    return await response.json();
+  }
+  async createAnalysis(input, callbacks) {
+    const formData = new FormData();
+    formData.append("description", input.description);
+    formData.append("timeStart", input.timeStart.toISOString());
+    formData.append("timeEnd", input.timeEnd.toISOString());
+    if (input.metadata) {
+      formData.append("metadata", JSON.stringify(input.metadata));
+    }
+    if (input.screenshot) {
+      formData.append("screenshot", input.screenshot);
+    }
+    const response = await fetch(`${this.baseUrl}/v1/analyses`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.apiKey}` },
+      body: formData
+    });
+    if (!callbacks) {
+      return await response.json();
+    }
+    return this.handleSSEStream(response, callbacks);
+  }
+  async handleSSEStream(response, callbacks) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+      const error = { code: "STREAM_ERROR", message: "No response body" };
+      callbacks.onError?.(error);
+      return { success: false, error };
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let finalResult;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      let currentEvent = "";
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          currentEvent = line.slice(7).trim();
+        } else if (line.startsWith("data: ") && currentEvent) {
+          const data = JSON.parse(line.slice(6));
+          const event = { event: currentEvent, data };
+          switch (event.event) {
+            case "status":
+              callbacks.onStatus?.(event.data.stage, event.data.detail);
+              break;
+            case "partial":
+              callbacks.onPartial?.(event.data);
+              break;
+            case "complete":
+              callbacks.onComplete?.(event.data.analysisId, event.data.result);
+              finalResult = { success: true, data: event.data };
+              break;
+            case "error":
+              callbacks.onError?.(event.data);
+              finalResult = { success: false, error: event.data };
+              break;
+          }
+          currentEvent = "";
+        }
+      }
+    }
+    return finalResult ?? { success: false, error: { code: "STREAM_ERROR", message: "Stream ended without result" } };
+  }
+  async getAnalysis(id) {
+    return this.request("GET", `/v1/analyses/${id}`);
+  }
+  async listAnalyses(query) {
+    const params = new URLSearchParams();
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) params.set(key, String(value));
+      }
+    }
+    const qs = params.toString();
+    return this.request("GET", `/v1/analyses${qs ? `?${qs}` : ""}`);
+  }
+  async askFollowUp(analysisId, question) {
+    return this.request("POST", `/v1/analyses/${analysisId}/followup`, {
+      question
+    });
+  }
+  async submitFeedback(analysisId, feedback) {
+    return this.request("POST", `/v1/analyses/${analysisId}/feedback`, feedback);
+  }
+};
+export {
+  ErrorCode,
+  SigSentryClient,
+  createLogger,
+  err,
+  isErr,
+  isOk,
+  ok
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@sigsentry/core",
+  "version": "0.1.0",
+  "description": "SigSentry core SDK — TypeScript API client, types, and utilities for AI-powered log analysis",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "keywords": [
+    "sigsentry",
+    "traceback",
+    "log-analysis",
+    "ai",
+    "api-client",
+    "sdk"
+  ],
+  "homepage": "https://sigsentry.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SigSentry/sdk",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/SigSentry/sdk/issues"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  }
+}