@sybil-studio-devs/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,396 @@
+interface SybilConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    resetAt: string;
+}
+interface ApiResponse<T> {
+    data: T;
+    meta?: {
+        rateLimit?: RateLimitInfo;
+    };
+}
+interface ApiError {
+    error: {
+        message: string;
+        code?: string;
+    };
+}
+interface PaginationParams {
+    limit?: number;
+    offset?: number;
+}
+interface Pagination {
+    total: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+interface Block {
+    type: string;
+    content?: Array<{
+        type: string;
+        text?: string;
+        [key: string]: any;
+    }>;
+    attrs?: Record<string, any>;
+    [key: string]: any;
+}
+interface Page {
+    id: string;
+    title: string;
+    slug: string;
+    description?: string;
+    blocks: Block[];
+    artifact_map?: Record<string, any>;
+    parent_id?: string | null;
+    is_published: boolean;
+    is_template: boolean;
+    version: number;
+    created_at: string;
+    updated_at: string;
+    metadata?: Record<string, any>;
+}
+interface CreatePageParams {
+    title?: string;
+    slug?: string;
+    description?: string;
+    blocks?: Block[];
+    parent_id?: string;
+}
+interface UpdatePageParams {
+    title?: string;
+    slug?: string;
+    description?: string | null;
+    blocks?: Block[];
+    is_published?: boolean;
+    parent_id?: string | null;
+}
+interface ListPagesParams extends PaginationParams {
+    parent_id?: string | 'root';
+    is_published?: boolean;
+}
+interface UploadResult {
+    url: string;
+    fileName: string;
+    fileSize: number;
+    mimeType: string;
+    path: string;
+}
+interface Document {
+    id: string;
+    title: string;
+    fileName: string;
+    fileType: string;
+    mimeType?: string;
+    fileSize: number;
+    status: DocumentStatus;
+    sourceUrl?: string;
+    sourceType?: string;
+    content?: string;
+    contentPreview?: string;
+    insights?: Insight[];
+    metadata?: DocumentMetadata;
+    createdAt: string;
+    updatedAt: string;
+    processedAt?: string;
+}
+type DocumentStatus = 'pending' | 'uploading' | 'processing' | 'extracting' | 'indexing' | 'processed' | 'completed' | 'failed';
+interface DocumentMetadata {
+    title?: string;
+    fileName?: string;
+    fileType?: string;
+    fileSize?: number;
+    documentType?: string;
+    category?: string;
+    keywords?: string[];
+    language?: string;
+    pageCount?: number;
+    wordCount?: number;
+    hasTranscript?: boolean;
+    semanticAnalysis?: SemanticAnalysis;
+}
+interface SemanticAnalysis {
+    topics?: string[];
+    entities?: Record<string, any[]>;
+    keyphrases?: string[];
+    domainTerms?: string[];
+}
+interface Insight {
+    id: string;
+    type: string;
+    title?: string;
+    content: string;
+    confidence?: number;
+    data?: any;
+    created_at?: string;
+}
+interface ProcessDocumentResult {
+    success: boolean;
+    documentId: string;
+    status: DocumentStatus;
+    message: string;
+    metadata: DocumentMetadata;
+    contentPreview?: string;
+    insights: Insight[];
+    processingTime: number;
+}
+interface DocumentStatusResult {
+    documentId: string;
+    status: DocumentStatus;
+    progress: number;
+    message: string;
+    startedAt?: string;
+    completedAt?: string;
+    error?: any;
+    hasInsights: boolean;
+    insightsCount: number;
+}
+interface ListDocumentsParams extends PaginationParams {
+    status?: DocumentStatus;
+    fileType?: string;
+    search?: string;
+}
+interface GetDocumentParams {
+    includeContent?: boolean;
+    includeInsights?: boolean;
+    includeMetadata?: boolean;
+}
+interface YouTubeVideo {
+    id: string;
+    videoId: string;
+    documentId: string;
+    title: string;
+    description?: string;
+    channelTitle: string;
+    channelId: string;
+    tags?: string[];
+    publishedAt: string;
+    duration: string;
+    viewCount: number;
+    likeCount: number;
+    commentCount: number;
+    thumbnailUrl: string;
+    transcriptAvailable: boolean;
+    transcriptLanguage?: string;
+    wordCount: number;
+    readingTime: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ProcessYouTubeResult {
+    status: 'success' | 'exists';
+    document: {
+        id: string;
+        title: string;
+        workspace_id: string;
+        source_url: string;
+        created_at: string;
+    };
+    video: {
+        videoId: string;
+        title: string;
+        channelTitle: string;
+        duration: string;
+        viewCount: number;
+        hasTranscript: boolean;
+    };
+    transcript: {
+        available: boolean;
+        wordCount: number;
+        chunkCount: number;
+    };
+    insights: {
+        count: number;
+        types: string[];
+    };
+    message: string;
+}
+interface GetYouTubeVideoParams {
+    includeTranscript?: boolean;
+    includeChunks?: boolean;
+    includeInsights?: boolean;
+}
+interface TranscriptChunk {
+    index: number;
+    startTime: number;
+    endTime: number;
+    content: string;
+    metadata?: Record<string, any>;
+}
+interface YouTubeVideoDetail extends YouTubeVideo {
+    transcript?: string;
+    chunks?: TranscriptChunk[];
+    insights?: Insight[];
+    semanticAnalysis?: SemanticAnalysis;
+}
+interface ChatMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+interface ChatParams {
+    query: string;
+    documentId: string;
+    conversationHistory?: ChatMessage[];
+    searchConfig?: {
+        semanticWeight?: number;
+        keywordWeight?: number;
+        maxResults?: number;
+        confidenceThreshold?: number;
+    };
+}
+interface ChatSource {
+    content: string;
+    similarity: number;
+    metadata?: Record<string, any>;
+}
+interface ChatResult {
+    response: string;
+    sources: ChatSource[];
+    metadata: {
+        documentId: string;
+        documentTitle: string;
+        sourcesCount: number;
+        confidence: number;
+        requestId: string;
+    };
+}
+interface ChatHistoryItem {
+    id: string;
+    query: string;
+    response: string;
+    type: string;
+    createdAt: string;
+    metadata?: Record<string, any>;
+}
+interface AnalyzeParams {
+    documentId: string;
+    forceRefresh?: boolean;
+}
+interface AnalysisResult {
+    analysis: any;
+    cached: boolean;
+    generatedAt: string;
+    document: {
+        id: string;
+        title: string;
+    };
+}
+
+declare class SybilSDK {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    pages: PagesAPI;
+    documents: DocumentsAPI;
+    youtube: YouTubeAPI;
+    chat: ChatAPI;
+    analyze: AnalyzeAPI;
+    constructor(config: string | SybilConfig);
+    request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+}
+declare class SybilError extends Error {
+    status: number;
+    code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+declare class PagesAPI {
+    private client;
+    constructor(client: SybilSDK);
+    list(params?: ListPagesParams): Promise<{
+        pages: Page[];
+        pagination: Pagination;
+    }>;
+    get(pageId: string): Promise<{
+        page: Page;
+    }>;
+    create(params?: CreatePageParams): Promise<{
+        page: Page;
+    }>;
+    update(pageId: string, params: UpdatePageParams): Promise<{
+        page: Page;
+    }>;
+    delete(pageId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    upload(file: File | Blob, fileName?: string): Promise<UploadResult>;
+    deleteFile(filePath: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+declare class DocumentsAPI {
+    private client;
+    constructor(client: SybilSDK);
+    list(params?: ListDocumentsParams): Promise<{
+        documents: Document[];
+        pagination: Pagination;
+    }>;
+    get(documentId: string, params?: GetDocumentParams): Promise<{
+        document: Document;
+    }>;
+    process(file: File | Blob, options?: {
+        fileName?: string;
+        metadata?: Record<string, any>;
+        collectionId?: string;
+    }): Promise<ProcessDocumentResult>;
+    status(documentId: string): Promise<DocumentStatusResult>;
+    insights(documentId: string, type?: string): Promise<{
+        documentId: string;
+        insights: Insight[];
+        semanticAnalysis?: any;
+    }>;
+    delete(documentId: string): Promise<{
+        success: boolean;
+        message: string;
+        documentId: string;
+    }>;
+    waitForProcessing(documentId: string, options?: {
+        maxAttempts?: number;
+        interval?: number;
+    }): Promise<Document>;
+}
+declare class YouTubeAPI {
+    private client;
+    constructor(client: SybilSDK);
+    list(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        videos: YouTubeVideo[];
+        pagination: Pagination;
+    }>;
+    process(url: string, collectionId?: string): Promise<ProcessYouTubeResult>;
+    get(videoId: string, params?: GetYouTubeVideoParams): Promise<{
+        video: YouTubeVideoDetail;
+    }>;
+    delete(videoId: string): Promise<{
+        success: boolean;
+        message: string;
+        videoId: string;
+    }>;
+}
+declare class ChatAPI {
+    private client;
+    constructor(client: SybilSDK);
+    send(params: ChatParams): Promise<ChatResult>;
+    send(documentId: string, query: string): Promise<ChatResult>;
+    history(documentId: string, limit?: number): Promise<{
+        history: ChatHistoryItem[];
+        total: number;
+    }>;
+}
+declare class AnalyzeAPI {
+    private client;
+    constructor(client: SybilSDK);
+    run(params: AnalyzeParams): Promise<AnalysisResult>;
+    run(documentId: string, forceRefresh?: boolean): Promise<AnalysisResult>;
+    get(documentId: string): Promise<AnalysisResult>;
+}
+
+export { type AnalysisResult, type AnalyzeParams, type ApiError, type ApiResponse, type Block, type ChatHistoryItem, type ChatMessage, type ChatParams, type ChatResult, type ChatSource, type CreatePageParams, type Document, type DocumentMetadata, type DocumentStatus, type DocumentStatusResult, type GetDocumentParams, type GetYouTubeVideoParams, type Insight, type ListDocumentsParams, type ListPagesParams, type Page, type Pagination, type PaginationParams, type ProcessDocumentResult, type ProcessYouTubeResult, type RateLimitInfo, type SemanticAnalysis, type SybilConfig, SybilError, SybilSDK, type TranscriptChunk, type UpdatePageParams, type UploadResult, type YouTubeVideo, type YouTubeVideoDetail, SybilSDK as default };

package/dist/index.js

@@ -0,0 +1,287 @@
+"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, {
+  SybilError: () => SybilError,
+  SybilSDK: () => SybilSDK,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://app.sybil.ai/api/sdk/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var SybilSDK = class {
+  constructor(config) {
+    if (typeof config === "string") {
+      this.apiKey = config;
+      this.baseUrl = DEFAULT_BASE_URL;
+      this.timeout = DEFAULT_TIMEOUT;
+    } else {
+      this.apiKey = config.apiKey;
+      this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+      this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    }
+    if (!this.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!this.apiKey.startsWith("sk_live_") && !this.apiKey.startsWith("sk_test_")) {
+      throw new Error("Invalid API key format. Must start with sk_live_ or sk_test_");
+    }
+    this.pages = new PagesAPI(this);
+    this.documents = new DocumentsAPI(this);
+    this.youtube = new YouTubeAPI(this);
+    this.chat = new ChatAPI(this);
+    this.analyze = new AnalyzeAPI(this);
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "x-api-key": this.apiKey,
+      ...options.headers
+    };
+    if (options.body && typeof options.body === "string") {
+      headers["Content-Type"] = "application/json";
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const message = errorData.error?.message || `Request failed with status ${response.status}`;
+        throw new SybilError(message, response.status, errorData.error?.code);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SybilError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new SybilError("Request timeout", 408, "TIMEOUT");
+      }
+      throw new SybilError(
+        error instanceof Error ? error.message : "Unknown error",
+        500,
+        "UNKNOWN"
+      );
+    }
+  }
+};
+var SybilError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "SybilError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var PagesAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    if (params.parent_id) searchParams.set("parent_id", params.parent_id);
+    if (params.is_published !== void 0) searchParams.set("is_published", params.is_published.toString());
+    const query = searchParams.toString();
+    return this.client.request(`/pages${query ? `?${query}` : ""}`);
+  }
+  async get(pageId) {
+    return this.client.request(`/pages/${pageId}`);
+  }
+  async create(params = {}) {
+    return this.client.request("/pages", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async update(pageId, params) {
+    return this.client.request(`/pages/${pageId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
+  }
+  async delete(pageId) {
+    return this.client.request(`/pages/${pageId}`, {
+      method: "DELETE"
+    });
+  }
+  async upload(file, fileName) {
+    const formData = new FormData();
+    formData.append("file", file, fileName);
+    return this.client.request("/pages/upload", {
+      method: "POST",
+      body: formData
+    });
+  }
+  async deleteFile(filePath) {
+    return this.client.request("/pages/upload", {
+      method: "DELETE",
+      body: JSON.stringify({ filePath })
+    });
+  }
+};
+var DocumentsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    if (params.status) searchParams.set("status", params.status);
+    if (params.fileType) searchParams.set("fileType", params.fileType);
+    if (params.search) searchParams.set("search", params.search);
+    const query = searchParams.toString();
+    return this.client.request(`/documents${query ? `?${query}` : ""}`);
+  }
+  async get(documentId, params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.includeContent) searchParams.set("includeContent", "true");
+    if (params.includeInsights === false) searchParams.set("includeInsights", "false");
+    if (params.includeMetadata === false) searchParams.set("includeMetadata", "false");
+    const query = searchParams.toString();
+    return this.client.request(`/documents/${documentId}${query ? `?${query}` : ""}`);
+  }
+  async process(file, options = {}) {
+    const formData = new FormData();
+    formData.append("file", file, options.fileName);
+    if (options.metadata) {
+      formData.append("metadata", JSON.stringify(options.metadata));
+    }
+    if (options.collectionId) {
+      formData.append("collectionId", options.collectionId);
+    }
+    return this.client.request("/documents", {
+      method: "POST",
+      body: formData
+    });
+  }
+  async status(documentId) {
+    return this.client.request(`/documents/${documentId}/status`);
+  }
+  async insights(documentId, type) {
+    const query = type ? `?type=${type}` : "";
+    return this.client.request(`/documents/${documentId}/insights${query}`);
+  }
+  async delete(documentId) {
+    return this.client.request(`/documents/${documentId}`, {
+      method: "DELETE"
+    });
+  }
+  async waitForProcessing(documentId, options = {}) {
+    const maxAttempts = options.maxAttempts || 60;
+    const interval = options.interval || 3e3;
+    for (let i = 0; i < maxAttempts; i++) {
+      const status = await this.status(documentId);
+      if (status.status === "processed" || status.status === "completed") {
+        const { document } = await this.get(documentId);
+        return document;
+      }
+      if (status.status === "failed") {
+        throw new SybilError(status.error?.message || "Processing failed", 500, "PROCESSING_FAILED");
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new SybilError("Processing timeout", 408, "TIMEOUT");
+  }
+};
+var YouTubeAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    const query = searchParams.toString();
+    return this.client.request(`/youtube${query ? `?${query}` : ""}`);
+  }
+  async process(url, collectionId) {
+    return this.client.request("/youtube", {
+      method: "POST",
+      body: JSON.stringify({ url, collectionId })
+    });
+  }
+  async get(videoId, params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.includeTranscript) searchParams.set("includeTranscript", "true");
+    if (params.includeChunks) searchParams.set("includeChunks", "true");
+    if (params.includeInsights === false) searchParams.set("includeInsights", "false");
+    const query = searchParams.toString();
+    return this.client.request(`/youtube/${videoId}${query ? `?${query}` : ""}`);
+  }
+  async delete(videoId) {
+    return this.client.request(`/youtube/${videoId}`, {
+      method: "DELETE"
+    });
+  }
+};
+var ChatAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async send(paramsOrDocId, query) {
+    const params = typeof paramsOrDocId === "string" ? { documentId: paramsOrDocId, query } : paramsOrDocId;
+    return this.client.request("/chat", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async history(documentId, limit) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("documentId", documentId);
+    if (limit) searchParams.set("limit", limit.toString());
+    return this.client.request(`/chat?${searchParams.toString()}`);
+  }
+};
+var AnalyzeAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async run(paramsOrDocId, forceRefresh) {
+    const params = typeof paramsOrDocId === "string" ? { documentId: paramsOrDocId, forceRefresh } : paramsOrDocId;
+    return this.client.request("/analyze", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async get(documentId) {
+    return this.client.request(`/analyze?documentId=${documentId}`);
+  }
+};
+
+// src/index.ts
+var index_default = SybilSDK;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SybilError,
+  SybilSDK
+});