@simonfestl/husky-cli 0.8.2 → 0.9.0

package/dist/lib/biz/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Biz Library Exports
+ */
+export { BillbeeClient } from './billbee.js';
+export { ZendeskClient } from './zendesk.js';
+export { SeaTableClient } from './seatable.js';
+export { QdrantClient } from './qdrant.js';
+export { EmbeddingService, EMBEDDING_MODELS } from './embeddings.js';
+export type { Point, SearchResult as QdrantSearchResult, SearchOptions, CollectionInfo, QdrantConfig } from './qdrant.js';
+export type { EmbeddingConfig, EmbeddingResult } from './embeddings.js';
+export * from './billbee-types.js';
+export * from './zendesk-types.js';
+export * from './seatable-types.js';

package/dist/lib/biz/index.js

@@ -0,0 +1,11 @@
+/**
+ * Biz Library Exports
+ */
+export { BillbeeClient } from './billbee.js';
+export { ZendeskClient } from './zendesk.js';
+export { SeaTableClient } from './seatable.js';
+export { QdrantClient } from './qdrant.js';
+export { EmbeddingService, EMBEDDING_MODELS } from './embeddings.js';
+export * from './billbee-types.js';
+export * from './zendesk-types.js';
+export * from './seatable-types.js';

package/dist/lib/biz/qdrant.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Qdrant Vector Database Client
+ * Ported from TigerV0 with Husky Biz CLI integration
+ */
+export interface QdrantConfig {
+    url: string;
+    apiKey?: string;
+}
+export interface Point {
+    id: string | number;
+    vector: number[];
+    payload?: Record<string, unknown>;
+}
+export interface SearchResult {
+    id: string | number;
+    score: number;
+    payload?: Record<string, unknown>;
+}
+export interface SearchOptions {
+    limit?: number;
+    filter?: Record<string, unknown>;
+    scoreThreshold?: number;
+    offset?: number;
+}
+export interface CollectionInfo {
+    name: string;
+    vectorsCount: number;
+    pointsCount: number;
+}
+export declare class QdrantClient {
+    private url;
+    private apiKey?;
+    constructor(config: QdrantConfig);
+    /**
+     * Create client from Husky config
+     */
+    static fromConfig(): QdrantClient;
+    private request;
+    listCollections(): Promise<string[]>;
+    getCollection(name: string): Promise<CollectionInfo>;
+    createCollection(name: string, vectorSize: number): Promise<void>;
+    deleteCollection(name: string): Promise<void>;
+    search(collectionName: string, vector: number[], limit?: number, options?: Omit<SearchOptions, 'limit'> & {
+        vectorName?: string;
+    }): Promise<SearchResult[]>;
+    upsert(collectionName: string, points: Point[]): Promise<void>;
+    upsertOne(collectionName: string, id: string | number, vector: number[], payload?: Record<string, unknown>): Promise<void>;
+    getPoint(collectionName: string, id: string | number): Promise<Point | null>;
+    deletePoints(collectionName: string, ids: (string | number)[]): Promise<void>;
+    count(collectionName: string): Promise<number>;
+}
+export default QdrantClient;

package/dist/lib/biz/qdrant.js

@@ -0,0 +1,158 @@
+/**
+ * Qdrant Vector Database Client
+ * Ported from TigerV0 with Husky Biz CLI integration
+ */
+import { getConfig } from '../../commands/config.js';
+// ============================================================================
+// Qdrant Service (REST API based)
+// ============================================================================
+export class QdrantClient {
+    url;
+    apiKey;
+    constructor(config) {
+        this.url = config.url.replace(/\/+$/, '');
+        this.apiKey = config.apiKey;
+    }
+    /**
+     * Create client from Husky config
+     */
+    static fromConfig() {
+        const config = getConfig();
+        const qdrantConfig = {
+            url: config.qdrantUrl || process.env.QDRANT_URL || 'http://localhost:6333',
+            apiKey: config.qdrantApiKey || process.env.QDRANT_API_KEY,
+        };
+        if (!qdrantConfig.url || qdrantConfig.url === 'http://localhost:6333') {
+            if (!process.env.QDRANT_URL) {
+                throw new Error('Missing Qdrant URL. Configure with:\n' +
+                    '  husky config set qdrant-url <url>\n' +
+                    '  husky config set qdrant-api-key <key>');
+            }
+        }
+        return new QdrantClient(qdrantConfig);
+    }
+    async request(path, options = {}) {
+        const url = `${this.url}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['api-key'] = this.apiKey;
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                ...headers,
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Qdrant API Error ${response.status}: ${error}`);
+        }
+        return response.json();
+    }
+    // =========================================================================
+    // Collections
+    // =========================================================================
+    async listCollections() {
+        const response = await this.request('/collections');
+        return response.result.collections.map(c => c.name);
+    }
+    async getCollection(name) {
+        const response = await this.request(`/collections/${name}`);
+        return {
+            name,
+            vectorsCount: response.result.vectors_count,
+            pointsCount: response.result.points_count,
+        };
+    }
+    async createCollection(name, vectorSize) {
+        await this.request(`/collections/${name}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                vectors: {
+                    size: vectorSize,
+                    distance: 'Cosine',
+                },
+            }),
+        });
+    }
+    async deleteCollection(name) {
+        await this.request(`/collections/${name}`, { method: 'DELETE' });
+    }
+    // =========================================================================
+    // Points
+    // =========================================================================
+    async search(collectionName, vector, limit = 10, options) {
+        // Build request body - support named vectors
+        const body = {
+            limit,
+            filter: options?.filter,
+            score_threshold: options?.scoreThreshold,
+            offset: options?.offset,
+            with_payload: true,
+        };
+        // If named vector, use object format
+        if (options?.vectorName) {
+            body.vector = { name: options.vectorName, vector };
+        }
+        else {
+            body.vector = vector;
+        }
+        const response = await this.request(`/collections/${collectionName}/points/search`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+        return response.result.map(r => ({
+            id: r.id,
+            score: r.score,
+            payload: r.payload,
+        }));
+    }
+    async upsert(collectionName, points) {
+        await this.request(`/collections/${collectionName}/points?wait=true`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                points: points.map(p => ({
+                    id: p.id,
+                    vector: p.vector,
+                    payload: p.payload || {},
+                })),
+            }),
+        });
+    }
+    async upsertOne(collectionName, id, vector, payload) {
+        await this.upsert(collectionName, [{ id, vector, payload }]);
+    }
+    async getPoint(collectionName, id) {
+        try {
+            const response = await this.request(`/collections/${collectionName}/points`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    ids: [id],
+                    with_payload: true,
+                    with_vector: true,
+                }),
+            });
+            if (response.result.length === 0)
+                return null;
+            const p = response.result[0];
+            return { id: p.id, vector: p.vector, payload: p.payload };
+        }
+        catch {
+            return null;
+        }
+    }
+    async deletePoints(collectionName, ids) {
+        await this.request(`/collections/${collectionName}/points/delete?wait=true`, {
+            method: 'POST',
+            body: JSON.stringify({ points: ids }),
+        });
+    }
+    async count(collectionName) {
+        const info = await this.getCollection(collectionName);
+        return info.pointsCount;
+    }
+}
+export default QdrantClient;

package/dist/lib/biz/seatable-types.d.ts

@@ -0,0 +1,115 @@
+/**
+ * SeaTable API Types
+ */
+/**
+ * Client configuration
+ */
+export interface SeaTableConfig {
+    apiToken: string;
+    serverUrl?: string;
+}
+/**
+ * Column Types in SeaTable
+ */
+export declare enum ColumnType {
+    Text = "text",
+    Number = "number",
+    Checkbox = "checkbox",
+    Date = "date",
+    SingleSelect = "single-select",
+    MultipleSelect = "multiple-select",
+    Image = "image",
+    File = "file",
+    Email = "email",
+    URL = "url",
+    Duration = "duration",
+    Rating = "rating",
+    Formula = "formula",
+    Link = "link",
+    Creator = "creator",
+    CreatedTime = "ctime",
+    LastModifier = "last-modifier",
+    ModifiedTime = "mtime"
+}
+/**
+ * SeaTable Row
+ */
+export interface SeaTableRow {
+    _id: string;
+    _ctime?: string;
+    _mtime?: string;
+    _creator?: string;
+    _last_modifier?: string;
+    [key: string]: unknown;
+}
+/**
+ * SeaTable Column
+ */
+export interface SeaTableColumn {
+    key: string;
+    name: string;
+    type: ColumnType;
+    width?: number;
+    editable?: boolean;
+    resizable?: boolean;
+    data?: {
+        link_id?: string;
+        other_table_id?: string;
+        options?: Array<{
+            name: string;
+            color: string;
+            textColor?: string;
+        }>;
+    };
+}
+/**
+ * SeaTable Table
+ */
+export interface SeaTableTable {
+    _id: string;
+    name: string;
+    columns: SeaTableColumn[];
+}
+/**
+ * SeaTable Base Metadata
+ */
+export interface SeaTableMetadata {
+    tables: SeaTableTable[];
+}
+/**
+ * Row Query Parameters
+ */
+export interface QueryRowsParams {
+    table_name: string;
+    view_name?: string;
+    order_by?: string;
+    direction?: 'asc' | 'desc';
+    start?: number;
+    limit?: number;
+}
+/**
+ * Filter Parameters
+ */
+export interface FilterParams {
+    filters?: Array<{
+        column_name: string;
+        filter_predicate: 'is' | 'is_not' | 'contains' | 'does_not_contain' | 'is_empty' | 'is_not_empty' | 'equal' | 'not_equal' | 'greater' | 'greater_or_equal' | 'less' | 'less_or_equal';
+        filter_term?: string | number | boolean;
+    }>;
+    filter_conjunction?: 'And' | 'Or';
+}
+/**
+ * Row Creation/Update Data
+ */
+export interface RowData {
+    [key: string]: string | number | boolean | string[] | null;
+}
+/**
+ * Query Response
+ */
+export interface QueryResponse {
+    rows: SeaTableRow[];
+    metadata?: {
+        total_count?: number;
+    };
+}

package/dist/lib/biz/seatable-types.js

@@ -0,0 +1,27 @@
+/**
+ * SeaTable API Types
+ */
+/**
+ * Column Types in SeaTable
+ */
+export var ColumnType;
+(function (ColumnType) {
+    ColumnType["Text"] = "text";
+    ColumnType["Number"] = "number";
+    ColumnType["Checkbox"] = "checkbox";
+    ColumnType["Date"] = "date";
+    ColumnType["SingleSelect"] = "single-select";
+    ColumnType["MultipleSelect"] = "multiple-select";
+    ColumnType["Image"] = "image";
+    ColumnType["File"] = "file";
+    ColumnType["Email"] = "email";
+    ColumnType["URL"] = "url";
+    ColumnType["Duration"] = "duration";
+    ColumnType["Rating"] = "rating";
+    ColumnType["Formula"] = "formula";
+    ColumnType["Link"] = "link";
+    ColumnType["Creator"] = "creator";
+    ColumnType["CreatedTime"] = "ctime";
+    ColumnType["LastModifier"] = "last-modifier";
+    ColumnType["ModifiedTime"] = "mtime";
+})(ColumnType || (ColumnType = {}));

package/dist/lib/biz/seatable.d.ts

@@ -0,0 +1,49 @@
+/**
+ * SeaTable API Client
+ * Ported from TigerV0 with Husky Biz CLI integration
+ *
+ * IMPORTANT: SeaTable uses a 2-stage token system:
+ * 1. API Token (permanent) - generated in SeaTable UI
+ * 2. Base Token (3 days TTL) - generated from API Token automatically
+ */
+import type { SeaTableConfig, SeaTableRow, SeaTableMetadata, QueryRowsParams, FilterParams, RowData, QueryResponse } from './seatable-types.js';
+export declare class SeaTableClient {
+    private serverUrl;
+    private apiToken;
+    private baseToken;
+    private baseTokenExpiry;
+    private dtableServer;
+    private dtableUuid;
+    constructor(config: SeaTableConfig);
+    /**
+     * Create client from Husky config
+     */
+    static fromConfig(): SeaTableClient;
+    private isApiGateway;
+    private buildEndpoint;
+    /**
+     * Get a Base Token from the API Token
+     * Base Tokens are valid for 3 days
+     */
+    private getBaseToken;
+    /**
+     * Make an authenticated API request
+     */
+    private request;
+    getMetadata(): Promise<SeaTableMetadata>;
+    listRows(params: QueryRowsParams): Promise<SeaTableRow[]>;
+    getRow(tableName: string, rowId: string): Promise<SeaTableRow | null>;
+    queryRows(tableName: string, filters: FilterParams, params?: Partial<QueryRowsParams>): Promise<QueryResponse>;
+    searchRows(tableName: string, searchQuery: string): Promise<SeaTableRow[]>;
+    appendRow(tableName: string, row: RowData): Promise<SeaTableRow>;
+    updateRow(tableName: string, rowId: string, data: RowData): Promise<{
+        success: boolean;
+    }>;
+    deleteRow(tableName: string, rowId: string): Promise<{
+        success: boolean;
+    }>;
+    deleteRows(tableName: string, rowIds: string[]): Promise<{
+        success: boolean;
+    }>;
+}
+export default SeaTableClient;

package/dist/lib/biz/seatable.js

@@ -0,0 +1,210 @@
+/**
+ * SeaTable API Client
+ * Ported from TigerV0 with Husky Biz CLI integration
+ *
+ * IMPORTANT: SeaTable uses a 2-stage token system:
+ * 1. API Token (permanent) - generated in SeaTable UI
+ * 2. Base Token (3 days TTL) - generated from API Token automatically
+ */
+import { getConfig } from '../../commands/config.js';
+export class SeaTableClient {
+    serverUrl;
+    apiToken;
+    baseToken = null;
+    baseTokenExpiry = null;
+    dtableServer = null;
+    dtableUuid = null;
+    constructor(config) {
+        this.apiToken = config.apiToken;
+        this.serverUrl = config.serverUrl || 'https://cloud.seatable.io';
+    }
+    /**
+     * Create client from Husky config
+     */
+    static fromConfig() {
+        const config = getConfig();
+        const seaTableConfig = {
+            apiToken: config.seatableApiToken || process.env.SEATABLE_API_TOKEN || '',
+            serverUrl: config.seatableServerUrl || process.env.SEATABLE_SERVER_URL || 'https://cloud.seatable.io',
+        };
+        if (!seaTableConfig.apiToken) {
+            throw new Error('Missing SeaTable API Token. Configure with:\n' +
+                '  husky config set seatable-api-token <token>\n\n' +
+                'Get your token from SeaTable: Base → Advanced → API Token');
+        }
+        return new SeaTableClient(seaTableConfig);
+    }
+    isApiGateway() {
+        return (this.dtableServer || '').includes('api-gateway');
+    }
+    buildEndpoint(path) {
+        const base = this.isApiGateway()
+            ? '/api/v2/dtables/'
+            : '/dtable-server/api/v1/dtables/';
+        return `${base}${this.dtableUuid || ''}${path}`;
+    }
+    /**
+     * Get a Base Token from the API Token
+     * Base Tokens are valid for 3 days
+     */
+    async getBaseToken() {
+        const now = Date.now();
+        if (this.baseToken && this.baseTokenExpiry && now < this.baseTokenExpiry) {
+            return;
+        }
+        const response = await fetch(`${this.serverUrl}/api/v2.1/dtable/app-access-token/`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Token ${this.apiToken}`,
+                'Accept': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to get SeaTable Base Token: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        this.baseToken = data.access_token;
+        this.dtableServer = data.dtable_server;
+        this.dtableUuid = data.dtable_uuid;
+        // Set expiry to 2.5 days from now (to be safe)
+        this.baseTokenExpiry = now + (2.5 * 24 * 60 * 60 * 1000);
+    }
+    /**
+     * Make an authenticated API request
+     */
+    async request(path, options = {}) {
+        await this.getBaseToken();
+        if (!this.dtableServer || !this.baseToken || !this.dtableUuid) {
+            throw new Error('Failed to obtain SeaTable Base Token');
+        }
+        const endpoint = this.buildEndpoint(path);
+        const baseUrl = (this.dtableServer || '').replace(/\/+$/, '');
+        const url = `${baseUrl}${endpoint}`;
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Authorization': `Bearer ${this.baseToken}`,
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`SeaTable API Error ${response.status}: ${error}`);
+        }
+        return response.json();
+    }
+    // =========================================================================
+    // METADATA
+    // =========================================================================
+    async getMetadata() {
+        const response = await this.request('/metadata/');
+        // Response may be { metadata: { tables: [...] } } or directly { tables: [...] }
+        if ('metadata' in response && response.metadata) {
+            return response.metadata;
+        }
+        return response;
+    }
+    // =========================================================================
+    // ROWS
+    // =========================================================================
+    async listRows(params) {
+        const query = new URLSearchParams({
+            table_name: params.table_name,
+        });
+        if (params.view_name)
+            query.set('view_name', params.view_name);
+        if (params.order_by)
+            query.set('order_by', params.order_by);
+        if (params.direction)
+            query.set('direction', params.direction);
+        if (params.start !== undefined)
+            query.set('start', String(params.start));
+        if (params.limit !== undefined)
+            query.set('limit', String(params.limit));
+        const response = await this.request(`/rows/?${query}`);
+        return response.rows;
+    }
+    async getRow(tableName, rowId) {
+        try {
+            const query = new URLSearchParams({
+                table_name: tableName,
+                row_id: rowId,
+            });
+            return await this.request(`/rows/?${query}`);
+        }
+        catch {
+            return null;
+        }
+    }
+    async queryRows(tableName, filters, params) {
+        const body = {
+            table_name: tableName,
+            filters: filters.filters || [],
+            filter_conjunction: filters.filter_conjunction || 'And',
+            ...params,
+        };
+        return this.request('/filtered-rows/', {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    async searchRows(tableName, searchQuery) {
+        const query = new URLSearchParams({
+            table_name: tableName,
+            q: searchQuery,
+        });
+        const response = await this.request(`/search/?${query}`);
+        return response.rows;
+    }
+    async appendRow(tableName, row) {
+        const response = await this.request('/rows/', {
+            method: 'POST',
+            body: JSON.stringify({
+                table_name: tableName,
+                rows: [row],
+            }),
+        });
+        if (response.rows?.[0])
+            return response.rows[0];
+        if (response.first_row)
+            return response.first_row;
+        let rowId = response.row_ids?.[0];
+        if (rowId && typeof rowId === 'object' && '_id' in rowId) {
+            const fetchedRow = await this.getRow(tableName, rowId._id);
+            if (fetchedRow)
+                return fetchedRow;
+        }
+        throw new Error('Unexpected append response from SeaTable');
+    }
+    async updateRow(tableName, rowId, data) {
+        return this.request('/rows/', {
+            method: 'PUT',
+            body: JSON.stringify({
+                table_name: tableName,
+                row_id: rowId,
+                row: data,
+            }),
+        });
+    }
+    async deleteRow(tableName, rowId) {
+        return this.request('/rows/', {
+            method: 'DELETE',
+            body: JSON.stringify({
+                table_name: tableName,
+                row_id: rowId,
+            }),
+        });
+    }
+    async deleteRows(tableName, rowIds) {
+        return this.request('/batch-delete-rows/', {
+            method: 'DELETE',
+            body: JSON.stringify({
+                table_name: tableName,
+                row_ids: rowIds,
+            }),
+        });
+    }
+}
+export default SeaTableClient;