@kaiban/sdk 0.1.9 → 0.3.0

package/dist/cjs/lib/http/errors.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerError = exports.UnavailableError = exports.RateLimitError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.ValidationError = exports.BadRequestError = exports.ApiError = exports.AbortedError = exports.TimeoutError = exports.HttpError = void 0;
+exports.mapHttpToSdkError = mapHttpToSdkError;
+class HttpError extends Error {
+    constructor(message, status, url, body) {
+        super(message);
+        this.name = 'HttpError';
+        this.status = status;
+        this.url = url;
+        this.body = body;
+    }
+}
+exports.HttpError = HttpError;
+class TimeoutError extends Error {
+    constructor(message = 'Request timed out') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+exports.TimeoutError = TimeoutError;
+class AbortedError extends Error {
+    constructor(message = 'Request was aborted') {
+        super(message);
+        this.name = 'AbortedError';
+    }
+}
+exports.AbortedError = AbortedError;
+class ApiError extends Error {
+    constructor(shape) {
+        super(shape.message);
+        this.name = 'ApiError';
+        this.code = shape.code;
+        this.details = shape.details;
+    }
+}
+exports.ApiError = ApiError;
+class BadRequestError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'BadRequestError';
+    }
+}
+exports.BadRequestError = BadRequestError;
+class ValidationError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class UnauthorizedError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'UnauthorizedError';
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+class ForbiddenError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'ForbiddenError';
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class NotFoundError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+class ConflictError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'ConflictError';
+    }
+}
+exports.ConflictError = ConflictError;
+class RateLimitError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class UnavailableError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'UnavailableError';
+    }
+}
+exports.UnavailableError = UnavailableError;
+class ServerError extends ApiError {
+    constructor(shape) {
+        super(shape);
+        this.name = 'ServerError';
+    }
+}
+exports.ServerError = ServerError;
+// Map HTTP response status and body to human-friendly SDK errors
+function mapHttpToSdkError(status, body) {
+    const shape = normalizeBody(body);
+    switch (status) {
+        case 400:
+            return new BadRequestError(shape);
+        case 401:
+            return new UnauthorizedError(shape);
+        case 403:
+            return new ForbiddenError(shape);
+        case 404:
+            return new NotFoundError(shape);
+        case 409:
+            return new ConflictError(shape);
+        case 422:
+            return new ValidationError(shape);
+        case 429:
+            return new RateLimitError(shape);
+        case 502:
+        case 503:
+        case 504:
+            return new UnavailableError(shape);
+        case 500:
+        default:
+            return new ServerError(shape);
+    }
+}
+function normalizeBody(body) {
+    if (!body)
+        return { message: 'Unknown error' };
+    if (typeof body === 'string')
+        return { message: body };
+    if (typeof body === 'object') {
+        const anyBody = body;
+        const code = anyBody['code'] || anyBody['error'];
+        const message = anyBody['message'] ||
+            anyBody['error_description'] ||
+            'Request failed';
+        const details = anyBody['details'];
+        return { code, message, details };
+    }
+    return { message: 'Request failed' };
+}

package/dist/cjs/lib/http/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lib/resources/ActivitiesClient.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivitiesClient = void 0;
+// Reuse ActivityCreate from shared types
+/**
+ * Client for managing card activities
+ * Activities track changes, comments, and events on cards
+ * @category Resources
+ */
+class ActivitiesClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List all activities with pagination, filters, and sorting
+     * Returns activities across all cards (use filters to narrow down)
+     *
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters (e.g., { card_id: '123', type: 'comment' })
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of activities
+     *
+     * @example
+     * ```typescript
+     * // Get activities with filters
+     * const result = await client.activities.list({
+     *   limit: 20,
+     *   order_by: '-created_at',
+     *   filters: { card_id: 'card-123', type: 'comment' }
+     * });
+     * console.log(result.data); // Array of Activity objects
+     *
+     * // Get next page
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.activities.list({
+     *     limit: 20,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
+     * ```
+     */
+    list(params, options) {
+        return this.http.list(`/activities`, params, options);
+    }
+    /**
+     * Iterate through all activities using async generator
+     * Automatically handles pagination by following next_cursor
+     *
+     * @param params - Optional query parameters (excluding after/before cursors)
+     * @param params.limit - Number of items per page (used internally for pagination)
+     * @param params.order_by - Fields to sort by (prefix with - for descending)
+     * @param params.filters - Filter parameters to narrow results
+     * @param options - Optional request configuration
+     *
+     * @yields Individual Activity objects
+     *
+     * @example
+     * ```typescript
+     * // Process all activities
+     * for await (const activity of client.activities.listAll()) {
+     *   console.log(activity.type, activity.description);
+     * }
+     *
+     * // With filters and custom page size
+     * for await (const activity of client.activities.listAll({
+     *   limit: 100,
+     *   order_by: '-created_at',
+     *   filters: { card_id: 'card-123', type: 'comment' }
+     * })) {
+     *   console.log(activity);
+     * }
+     * ```
+     */
+    async *listAll(params, options) {
+        let cursor = undefined;
+        do {
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
+            for (const item of page.data)
+                yield item;
+            cursor = page.pagination.next_cursor;
+        } while (cursor);
+    }
+    /**
+     * Create a new activity
+     * Activities can track various events such as comments, status changes, or custom events
+     *
+     * @param data - Activity creation data
+     * @param data.card_id - The unique identifier of the card
+     * @param data.board_id - The board ID
+     * @param data.team_id - The team ID
+     * @param data.type - The type of activity (e.g., 'card_created', 'card_updated', 'comment')
+     * @param data.description - A description of the activity
+     * @param data.actor - The actor who performed the activity
+     * @param data.changes - Optional array of field changes
+     * @param data.metadata - Optional additional metadata
+     * @param options - Optional request configuration
+     *
+     * @returns The created activity object
+     *
+     * @throws {Error} If creation fails
+     *
+     * @example
+     * ```typescript
+     * const activity = await client.activities.create({
+     *   card_id: 'card-123',
+     *   board_id: 'board-456',
+     *   team_id: 'team-789',
+     *   type: 'comment',
+     *   description: 'Added a comment',
+     *   actor: {
+     *     id: 'user-001',
+     *     type: 'user',
+     *     name: 'Jane Doe'
+     *   }
+     * });
+     * ```
+     */
+    create(data, options) {
+        return this.http.post(`/activities:batch`, { items: [data] }, options);
+    }
+    /**
+     * Create multiple activities in a single batch request
+     * This is more efficient than creating activities one by one
+     *
+     * @param data - Array of activity creation data
+     * @param options - Optional request configuration
+     *
+     * @returns The batch creation result
+     *
+     * @throws {Error} If batch creation fails
+     *
+     * @example
+     * ```typescript
+     * const activities = await client.activities.createBatch([
+     *   {
+     *     card_id: 'card-123',
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'comment',
+     *     description: 'First comment',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' }
+     *   },
+     *   {
+     *     card_id: 'card-123',
+     *     board_id: 'board-456',
+     *     team_id: 'team-789',
+     *     type: 'card_updated',
+     *     description: 'Updated priority',
+     *     actor: { id: 'user-001', type: 'user', name: 'Jane Doe' },
+     *     changes: [{ field: 'priority', old_value: 'low', new_value: 'high' }]
+     *   }
+     * ]);
+     * ```
+     */
+    createBatch(data, options) {
+        return this.http.post(`/activities:batch`, { items: data }, options);
+    }
+}
+exports.ActivitiesClient = ActivitiesClient;

package/dist/cjs/lib/resources/AgentsClient.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentsClient = void 0;
+/**
+ * Client for managing agents in the Kaiban platform
+ * @category Resources
+ */
+class AgentsClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List agents with pagination, filters, and sorting
+     *
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters to narrow results
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of agents
+     *
+     * @example
+     * ```typescript
+     * // List first page of agents
+     * const result = await client.agents.list({ limit: 10 });
+     * console.log(result.data); // Array of Agent objects
+     * console.log(result.pagination.next_cursor); // Cursor for next page
+     *
+     * // Get next page using cursor
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.agents.list({
+     *     limit: 10,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
+     *
+     * // With filters and sorting
+     * const filtered = await client.agents.list({
+     *   limit: 20,
+     *   order_by: '-created_at',
+     *   filters: { status: 'active' }
+     * });
+     * ```
+     */
+    list(params, options) {
+        return this.http.list('/agents', params, options);
+    }
+    /**
+     * Iterate through all agents using async generator
+     * Automatically handles pagination by following next_cursor
+     *
+     * @param params - Optional query parameters (excluding after/before cursors)
+     * @param params.limit - Number of items per page (used internally for pagination)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param params.filters - Filter parameters to narrow results
+     * @param options - Optional request configuration
+     *
+     * @yields Individual Agent objects
+     *
+     * @example
+     * ```typescript
+     * // Iterate through all agents
+     * for await (const agent of client.agents.listAll()) {
+     *   console.log(agent.id, agent.name);
+     * }
+     *
+     * // With custom page size and sorting
+     * for await (const agent of client.agents.listAll({
+     *   limit: 100,
+     *   order_by: '-created_at',
+     *   filters: { status: 'active' }
+     * })) {
+     *   console.log(agent);
+     * }
+     * ```
+     */
+    async *listAll(params, options) {
+        let cursor = undefined;
+        do {
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
+            for (const item of page.data)
+                yield item;
+            cursor = page.pagination.next_cursor;
+        } while (cursor);
+    }
+    /**
+     * Get a single agent by ID
+     *
+     * @param id - The unique identifier of the agent
+     * @param options - Optional request configuration
+     *
+     * @returns The agent object
+     *
+     * @throws {Error} If the agent is not found or request fails
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.get('agent-123');
+     * console.log(agent.name, agent.status);
+     * ```
+     */
+    get(id, options) {
+        return this.http.get(`/agent/${encodeURIComponent(id)}`, options);
+    }
+    /**
+     * Create a new agent
+     *
+     * @param data - Agent creation data
+     * @param options - Optional request configuration
+     *
+     * @returns The newly created agent object
+     *
+     * @throws {Error} If creation fails
+     *
+     * @example
+     * ```typescript
+     * const agent = await client.agents.create({
+     *   name: 'SupportAgent',
+     *   description: 'Handles support tickets',
+     *   team_id: 'team_123',
+     *   owner_id: 'user_123',
+     *   created_by: 'user_123',
+     *   type: 'a2a',
+     *   status: 'active',
+     *   monthly_budget: 200,
+     *   examples: []
+     * });
+     * ```
+     */
+    create(data, options) {
+        return this.http.post('/agents', data, options);
+    }
+    /**
+     * Update an agent's properties
+     *
+     * @param id - The unique identifier of the agent to update
+     * @param data - Partial agent data with fields to update
+     * @param options - Optional request configuration
+     *
+     * @returns The updated agent object
+     *
+     * @throws {Error} If the agent is not found or update fails
+     *
+     * @example
+     * ```typescript
+     * const updatedAgent = await client.agents.update('agent-123', {
+     *   name: 'New Name',
+     *   status: 'active'
+     * });
+     * ```
+     */
+    update(id, data, options) {
+        return this.http.put(`/agent/${encodeURIComponent(id)}`, data, options);
+    }
+    /**
+     * Create feedback for an agent
+     *
+     * @param agentId - The unique identifier of the agent
+     * @param feedback - Feedback data to submit
+     * @param options - Optional request configuration
+     *
+     * @returns Promise that resolves when feedback is created
+     *
+     * @throws {Error} If the agent is not found or feedback creation fails
+     *
+     * @example
+     * ```typescript
+     * await client.agents.createFeedback('agent-123', {
+     *   rating: 5,
+     *   comment: 'Excellent performance',
+     *   tags: ['helpful', 'accurate']
+     * });
+     * ```
+     */
+    createFeedback(agentId, feedback, options) {
+        return this.http.post(`/agent/${encodeURIComponent(agentId)}/feedback`, {
+            ...feedback,
+            agent_id: agentId,
+        }, options);
+    }
+    /**
+     * List supervisor feedback for a specific agent with pagination
+     *
+     * @param agentId - The unique identifier of the agent
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.limit - Number of items per page (default: 50, max: 100)
+     * @param params.after - Cursor to navigate forwards (get items after this cursor)
+     * @param params.before - Cursor to navigate backwards (get items before this cursor)
+     * @param params.order_by - Fields to sort by (prefix with - for descending order)
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of supervisor feedback for the agent
+     *
+     * @throws {Error} If the agent is not found or request fails
+     *
+     * @example
+     * ```typescript
+     * // List supervisor feedback for an agent
+     * const result = await client.agents.listSupervisorFeedbacks('agent-123', {
+     *   limit: 10,
+     *   order_by: '-created_at'
+     * });
+     *
+     * for (const feedback of result.data) {
+     *   console.log(feedback.rating, feedback.comment);
+     * }
+     *
+     * // Get next page if available
+     * if (result.pagination.next_cursor) {
+     *   const nextPage = await client.agents.listSupervisorFeedbacks('agent-123', {
+     *     limit: 10,
+     *     after: result.pagination.next_cursor
+     *   });
+     * }
+     * ```
+     */
+    listSupervisorFeedback(agentId, params, options) {
+        return this.http.list(`/supervisor-feedback/${encodeURIComponent(agentId)}`, params, options);
+    }
+}
+exports.AgentsClient = AgentsClient;

package/dist/cjs/lib/resources/BoardsClient.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoardsClient = void 0;
+/**
+ * Client for managing boards in the Kaiban platform
+ * Boards organize cards into columns for workflow management
+ * @category Resources
+ */
+class BoardsClient {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List boards with pagination, filters, and sorting
+     *
+     * @param params - Optional query parameters for filtering and pagination
+     * @param params.cursor - Cursor for the next page of results
+     * @param params.limit - Number of items per page
+     * @param params.order_by - Fields to sort by
+     * @param options - Optional request configuration
+     *
+     * @returns A paginated list of boards
+     *
+     * @example
+     * ```typescript
+     * const result = await client.boards.list({ limit: 10 });
+     * console.log(result.data);
+     * ```
+     */
+    list(params, options) {
+        return this.http.list('/boards', params, options);
+    }
+    /**
+     * Iterate through all boards using async generator
+     * Automatically handles pagination by following next_page_token
+     *
+     * @param params - Optional query parameters (excluding cursor)
+     * @param options - Optional request configuration
+     *
+     * @yields Individual Board objects
+     *
+     * @example
+     * ```typescript
+     * for await (const board of client.boards.listAll()) {
+     *   console.log(board.id, board.name);
+     * }
+     * ```
+     */
+    async *listAll(params, options) {
+        let cursor = undefined;
+        do {
+            const page = await this.list({ ...(params || {}), after: cursor }, options);
+            for (const item of page.data)
+                yield item;
+            cursor = page.pagination.next_cursor;
+        } while (cursor);
+    }
+    /**
+     * Get a single board by ID
+     *
+     * @param id - The unique identifier of the board
+     * @param options - Optional request configuration
+     *
+     * @returns The board object
+     *
+     * @throws {Error} If the board is not found or request fails
+     *
+     * @example
+     * ```typescript
+     * const board = await client.boards.get('board-123');
+     * console.log(board.name, board.columns);
+     * ```
+     */
+    get(id, options) {
+        return this.http.get(`/board/${encodeURIComponent(id)}`, options);
+    }
+    /**
+     * Create a new board
+     *
+     * @param data - Board creation data
+     * @param data.name - The board name
+     * @param data.team_id - The team this board belongs to
+     * @param data.owner_id - The owner of the board
+     * @param data.created_by - The user creating the board
+     * @param data.description - Board description
+     * @param data.agent_ids - Array of agent IDs
+     * @param data.member_ids - Array of member IDs
+     * @param data.allowed_roles - Array of allowed roles
+     * @param data.columns - Array of columns
+     * @param options - Optional request configuration
+     *
+     * @returns The newly created board
+     *
+     * @throws {Error} If creation fails
+     *
+     * @example
+     * ```typescript
+     * const board = await client.boards.create({
+     *   name: 'Sales',
+     *   team_id: 'team_123',
+     *   owner_id: 'user_123',
+     *   created_by: 'user_123',
+     *   description: 'Manage pipeline',
+     *   columns: []
+     *   // agent_ids, member_ids, and allowed_roles are optional (default to [])
+     * });
+     * ```
+     */
+    create(data, options) {
+        // Default empty arrays for optional fields
+        const payload = {
+            ...data,
+            agent_ids: data.agent_ids ?? [],
+            member_ids: data.member_ids ?? [],
+            allowed_roles: data.allowed_roles ?? [],
+        };
+        return this.http.post('/boards', payload, options);
+    }
+}
+exports.BoardsClient = BoardsClient;