@simonfestl/husky-cli 0.8.2 → 0.9.0

package/dist/index.js

@@ -13,17 +13,19 @@ import { workflowCommand } from "./commands/workflow.js";
 import { julesCommand } from "./commands/jules.js";
 import { vmCommand } from "./commands/vm.js";
 import { vmConfigCommand } from "./commands/vm-config.js";
+import { processCommand } from "./commands/process.js";
 import { settingsCommand } from "./commands/settings.js";
 import { strategyCommand } from "./commands/strategy.js";
 import { completionCommand } from "./commands/completion.js";
 import { worktreeCommand } from "./commands/worktree.js";
 import { workerCommand } from "./commands/worker.js";
+import { bizCommand } from "./commands/biz.js";
 import { runInteractiveMode } from "./commands/interactive.js";
 const program = new Command();
 program
     .name("husky")
     .description("CLI for Huskyv0 Task Orchestration with Claude Agent")
-    .version("0.8.1");
+    .version("0.6.0");
 program.addCommand(taskCommand);
 program.addCommand(configCommand);
 program.addCommand(agentCommand);
@@ -37,11 +39,13 @@ program.addCommand(workflowCommand);
 program.addCommand(julesCommand);
 program.addCommand(vmCommand);
 program.addCommand(vmConfigCommand);
+program.addCommand(processCommand);
 program.addCommand(settingsCommand);
 program.addCommand(strategyCommand);
 program.addCommand(completionCommand);
 program.addCommand(worktreeCommand);
 program.addCommand(workerCommand);
+program.addCommand(bizCommand);
 // Check if no command was provided - run interactive mode
 if (process.argv.length <= 2) {
     runInteractiveMode();

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

@@ -0,0 +1,259 @@
+/**
+ * Billbee API Types
+ * Full coverage from TigerV0 integrations
+ */
+export interface BillbeeConfig {
+    API_KEY: string;
+    USERNAME: string;
+    PASSWORD: string;
+    BASE_URL: string;
+}
+export interface Paging {
+    Page: number;
+    TotalPages: number;
+    TotalRows: number;
+    PageSize: number;
+}
+export interface BillbeePaginatedResponse<T> {
+    Paging: Paging;
+    Data: T[];
+}
+export interface BillbeeResponse<T> {
+    Data: T;
+}
+export interface Address {
+    BillbeeId?: number;
+    FirstName?: string;
+    LastName?: string;
+    Company?: string;
+    NameAddition?: string;
+    Street?: string;
+    HouseNumber?: string;
+    Zip?: string;
+    City?: string;
+    State?: string;
+    CountryISO2?: string;
+    Country?: string;
+    Email?: string;
+    Phone?: string;
+}
+export interface OrderItem {
+    BillbeeId?: number;
+    TransactionId?: string;
+    Product?: {
+        Id?: string;
+        Title?: string;
+        Weight?: number;
+        SKU?: string;
+        EAN?: string;
+    };
+    Quantity: number;
+    TotalPrice: number;
+    TaxAmount?: number;
+    TaxIndex?: number;
+    Discount?: number;
+    Attributes?: Array<{
+        Id?: string;
+        Name?: string;
+        Value?: string;
+    }>;
+}
+export interface Payment {
+    BillbeeId?: number;
+    TransactionId?: string;
+    PayDate?: string;
+    PaymentType?: number;
+    SourceTechnology?: string;
+    SourceText?: string;
+    PayValue?: number;
+    Purpose?: string;
+    Name?: string;
+}
+export interface Order {
+    BillbeeId?: number;
+    Id: number | null;
+    BillBeeOrderId?: number;
+    OrderNumber: string | null;
+    State?: number;
+    VatMode?: number;
+    CreatedAt?: string;
+    ShippedAt?: string;
+    ConfirmedAt?: string;
+    PayedAt?: string;
+    SellerComment?: string;
+    Comments?: Array<{
+        Id?: number;
+        FromCustomer?: boolean;
+        Text?: string;
+        Name?: string;
+        Created?: string;
+    }>;
+    InvoiceNumber?: string;
+    InvoiceCreatedAt?: string;
+    InvoiceDate?: string;
+    Currency?: string;
+    UpdatedAt?: string;
+    TaxRate1?: number;
+    TaxRate2?: number;
+    TotalCost?: number;
+    ShippingCost?: number;
+    OrderItems?: OrderItem[];
+    Seller?: {
+        Platform?: string;
+        BillbeeShopName?: string;
+        BillbeeShopId?: number;
+    };
+    Buyer?: {
+        BillbeeId?: number;
+        Email?: string;
+    };
+    InvoiceAddress?: Address;
+    ShippingAddress?: Address;
+    Payments?: Payment[];
+    Tags?: string[];
+}
+export interface OrdersQueryParams {
+    page?: number;
+    pageSize?: number;
+    minOrderDate?: string;
+    maxOrderDate?: string;
+    shopId?: number[];
+    orderStateId?: number[];
+    tag?: string[];
+    minPayDate?: string;
+    maxPayDate?: string;
+    includePositions?: boolean;
+}
+export interface Stock {
+    Name: string;
+    StockId: number;
+    StockCurrent: number;
+    StockWarning?: number;
+    StockCode?: string;
+    UnfulfilledAmount?: number;
+    StockDesired?: number;
+}
+export interface ProductImage {
+    Url: string;
+    Id?: number;
+    IsDefaultImage?: boolean;
+    Position?: number;
+}
+export interface ProductSource {
+    Id?: number;
+    Source?: string;
+    SourceId?: string;
+    ApiAccountName?: string;
+    ApiAccountId?: number;
+    ExportFactor?: number;
+    StockSyncInactive?: boolean;
+    StockSyncMin?: number;
+    StockSyncMax?: number;
+    UnitsPerItem?: number;
+}
+export interface Product {
+    Id?: number;
+    Title?: string;
+    InvoiceText?: string;
+    ShortDescription?: string;
+    Description?: string;
+    SKU?: string;
+    EAN?: string;
+    TaricNumber?: string;
+    CountryOfOrigin?: string;
+    Price?: number;
+    CostPrice?: number;
+    VAT?: string;
+    VATIndex?: number;
+    Weight?: number;
+    WeightNet?: number;
+    LowStock?: boolean;
+    StockCurrent?: number;
+    StockDesired?: number;
+    StockWarning?: number;
+    Stocks?: Stock[];
+    Images?: ProductImage[];
+    Manufacturer?: string;
+    Type?: number;
+    Category1?: string;
+    Category2?: string;
+    Category3?: string;
+    Unit?: number;
+    UnitsPerItem?: number;
+    SoldAmountLast30Days?: number;
+    Sources?: ProductSource[];
+    IsDigital?: boolean;
+    IsCustomizable?: boolean;
+    DeliveryTime?: number;
+    Recipient?: number;
+    Occasion?: number;
+    Condition?: number;
+    WidthCm?: number;
+    LengthCm?: number;
+    HeightCm?: number;
+    BillOfMaterial?: Array<{
+        ProductId?: number;
+        Amount?: number;
+        ArticleId?: number;
+        SKU?: string;
+    }>;
+}
+export interface ProductsQueryParams {
+    page?: number;
+    pageSize?: number;
+    minCreatedAt?: string;
+    type?: number;
+    includeCategories?: boolean;
+}
+export interface ProductUpdate {
+    Title?: string;
+    InvoiceText?: string;
+    ShortDescription?: string;
+    Description?: string;
+    SKU?: string;
+    EAN?: string;
+    TaricNumber?: string;
+    CountryOfOrigin?: string;
+    Price?: number;
+    CostPrice?: number;
+    VAT?: string;
+    VATIndex?: number;
+    Weight?: number;
+    WeightNet?: number;
+    Manufacturer?: string;
+    Type?: number;
+    Category1?: string;
+    Category2?: string;
+    Category3?: string;
+    Unit?: number;
+    UnitsPerItem?: number;
+    Images?: ProductImage[];
+    IsDigital?: boolean;
+    IsCustomizable?: boolean;
+    DeliveryTime?: number;
+    WidthCm?: number;
+    LengthCm?: number;
+    HeightCm?: number;
+    LowStock?: boolean;
+    StockDesired?: number;
+    StockWarning?: number;
+}
+export declare const OrderState: {
+    readonly Ordered: 1;
+    readonly Confirmed: 2;
+    readonly Paid: 3;
+    readonly Shipped: 4;
+    readonly ReclamationOrReturn: 5;
+    readonly Deleted: 6;
+    readonly Completed: 7;
+    readonly Cancelled: 8;
+    readonly Archived: 9;
+    readonly NotUsed: 10;
+    readonly Demanded: 11;
+    readonly PackingStarted: 12;
+    readonly Ready: 13;
+    readonly Clarification: 14;
+    readonly Warning: 15;
+};
+export type OrderStateId = (typeof OrderState)[keyof typeof OrderState];
+export declare const OrderStateLabels: Record<number, string>;

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

@@ -0,0 +1,41 @@
+/**
+ * Billbee API Types
+ * Full coverage from TigerV0 integrations
+ */
+// ============================================================================
+// Order States
+// ============================================================================
+export const OrderState = {
+    Ordered: 1,
+    Confirmed: 2,
+    Paid: 3,
+    Shipped: 4,
+    ReclamationOrReturn: 5,
+    Deleted: 6,
+    Completed: 7,
+    Cancelled: 8,
+    Archived: 9,
+    NotUsed: 10,
+    Demanded: 11,
+    PackingStarted: 12,
+    Ready: 13,
+    Clarification: 14,
+    Warning: 15,
+};
+export const OrderStateLabels = {
+    1: 'ordered',
+    2: 'confirmed',
+    3: 'paid',
+    4: 'shipped',
+    5: 'return',
+    6: 'deleted',
+    7: 'completed',
+    8: 'cancelled',
+    9: 'archived',
+    10: 'not_used',
+    11: 'demanded',
+    12: 'packing',
+    13: 'ready',
+    14: 'clarification',
+    15: 'warning',
+};

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

@@ -0,0 +1,37 @@
+/**
+ * Billbee API Client
+ * Extended for v0.9 with full products support
+ */
+import { BillbeeConfig, BillbeePaginatedResponse, BillbeeResponse, Order, OrdersQueryParams, Product, ProductsQueryParams, ProductUpdate } from './billbee-types.js';
+export declare class BillbeeClient {
+    private config;
+    constructor(config: BillbeeConfig);
+    /**
+     * Create client from Husky config
+     */
+    static fromConfig(): BillbeeClient;
+    /**
+     * Make authenticated request (with rate limit awareness: 2 req/sec max)
+     */
+    private request;
+    listOrders(params?: OrdersQueryParams): Promise<BillbeePaginatedResponse<Order>>;
+    getOrder(id: number | string): Promise<BillbeeResponse<Order>>;
+    updateOrder(id: number | string, data: Partial<Order>): Promise<BillbeeResponse<Order>>;
+    addOrderTags(orderId: number, tags: string[]): Promise<void>;
+    removeOrderTags(orderId: number, tags: string[]): Promise<void>;
+    listProducts(params?: ProductsQueryParams): Promise<BillbeePaginatedResponse<Product>>;
+    getProduct(id: number | string): Promise<BillbeeResponse<Product>>;
+    getProductBySku(sku: string): Promise<Product | null>;
+    updateProduct(id: number | string, data: ProductUpdate): Promise<BillbeeResponse<Product>>;
+    updateProductBySku(sku: string, data: ProductUpdate): Promise<BillbeeResponse<Product>>;
+    /**
+     * Search customers by email (scans orders for matching buyers)
+     */
+    findCustomerByEmail(email: string): Promise<{
+        buyer: Order['Buyer'];
+        address: Order['InvoiceAddress'];
+        orders: Order[];
+    } | null>;
+}
+export type { Address } from './billbee-types.js';
+export default BillbeeClient;

package/dist/lib/biz/billbee.js

@@ -0,0 +1,165 @@
+/**
+ * Billbee API Client
+ * Extended for v0.9 with full products support
+ */
+import { getConfig } from '../../commands/config.js';
+export class BillbeeClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Create client from Husky config
+     */
+    static fromConfig() {
+        const config = getConfig();
+        const billbeeConfig = {
+            API_KEY: config.billbeeApiKey || process.env.BILLBEE_API_KEY || '',
+            USERNAME: config.billbeeUsername || process.env.BILLBEE_USERNAME || '',
+            PASSWORD: config.billbeePassword || process.env.BILLBEE_PASSWORD || '',
+            BASE_URL: config.billbeeBaseUrl || process.env.BILLBEE_BASE_URL || 'https://app.billbee.io/api/v1',
+        };
+        if (!billbeeConfig.API_KEY || !billbeeConfig.USERNAME || !billbeeConfig.PASSWORD) {
+            throw new Error('Missing Billbee credentials. Configure with:\n' +
+                '  husky config set billbee-api-key <key>\n' +
+                '  husky config set billbee-username <email>\n' +
+                '  husky config set billbee-password <password>');
+        }
+        return new BillbeeClient(billbeeConfig);
+    }
+    /**
+     * Make authenticated request (with rate limit awareness: 2 req/sec max)
+     */
+    async request(endpoint, options = {}) {
+        const url = `${this.config.BASE_URL}${endpoint}`;
+        const auth = Buffer.from(`${this.config.USERNAME}:${this.config.PASSWORD}`).toString('base64');
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'X-Billbee-Api-Key': this.config.API_KEY,
+                'Authorization': `Basic ${auth}`,
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Billbee API Error ${response.status}: ${error}`);
+        }
+        return response.json();
+    }
+    // =========================================================================
+    // ORDERS
+    // =========================================================================
+    async listOrders(params) {
+        const query = new URLSearchParams();
+        if (params?.page)
+            query.set('page', String(params.page));
+        if (params?.pageSize)
+            query.set('pageSize', String(params.pageSize));
+        if (params?.minOrderDate)
+            query.set('minOrderDate', params.minOrderDate);
+        if (params?.maxOrderDate)
+            query.set('maxOrderDate', params.maxOrderDate);
+        if (params?.includePositions !== undefined) {
+            query.set('includePositions', String(params.includePositions));
+        }
+        if (params?.orderStateId && params.orderStateId.length > 0) {
+            params.orderStateId.forEach(id => query.append('orderStateId', String(id)));
+        }
+        if (params?.tag && params.tag.length > 0) {
+            params.tag.forEach(t => query.append('tag', t));
+        }
+        const endpoint = `/orders${query.toString() ? `?${query}` : ''}`;
+        return this.request(endpoint);
+    }
+    async getOrder(id) {
+        return this.request(`/orders/${id}`);
+    }
+    async updateOrder(id, data) {
+        return this.request(`/orders/${id}`, {
+            method: 'PUT',
+            body: JSON.stringify(data),
+        });
+    }
+    async addOrderTags(orderId, tags) {
+        await this.request(`/orders/${orderId}/tags`, {
+            method: 'POST',
+            body: JSON.stringify({ Tags: tags }),
+        });
+    }
+    async removeOrderTags(orderId, tags) {
+        await this.request(`/orders/${orderId}/tags`, {
+            method: 'DELETE',
+            body: JSON.stringify({ Tags: tags }),
+        });
+    }
+    // =========================================================================
+    // PRODUCTS
+    // =========================================================================
+    async listProducts(params) {
+        const query = new URLSearchParams();
+        if (params?.page)
+            query.set('page', String(params.page));
+        if (params?.pageSize)
+            query.set('pageSize', String(params.pageSize));
+        if (params?.minCreatedAt)
+            query.set('minCreatedAt', params.minCreatedAt);
+        if (params?.type !== undefined)
+            query.set('type', String(params.type));
+        const endpoint = `/products${query.toString() ? `?${query}` : ''}`;
+        return this.request(endpoint);
+    }
+    async getProduct(id) {
+        return this.request(`/products/${id}`);
+    }
+    async getProductBySku(sku) {
+        try {
+            const response = await this.request(`/products/query?LookupBy=sku&LookupTerm=${encodeURIComponent(sku)}`);
+            return response.Data;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('404')) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async updateProduct(id, data) {
+        return this.request(`/products/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify(data),
+        });
+    }
+    async updateProductBySku(sku, data) {
+        const product = await this.getProductBySku(sku);
+        if (!product || !product.Id) {
+            throw new Error(`Product with SKU "${sku}" not found`);
+        }
+        return this.updateProduct(product.Id, data);
+    }
+    // =========================================================================
+    // CUSTOMERS (from Orders)
+    // =========================================================================
+    /**
+     * Search customers by email (scans orders for matching buyers)
+     */
+    async findCustomerByEmail(email) {
+        const response = await this.listOrders({
+            pageSize: 100,
+            includePositions: false,
+        });
+        const matchingOrders = response.Data.filter(order => order.Buyer?.Email?.toLowerCase() === email.toLowerCase() ||
+            order.InvoiceAddress?.Email?.toLowerCase() === email.toLowerCase());
+        if (matchingOrders.length === 0) {
+            return null;
+        }
+        const latestOrder = matchingOrders[0];
+        return {
+            buyer: latestOrder.Buyer,
+            address: latestOrder.InvoiceAddress || {},
+            orders: matchingOrders,
+        };
+    }
+}
+export default BillbeeClient;

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

@@ -0,0 +1,45 @@
+/**
+ * Vertex AI Embedding Service
+ * Ported from TigerV0 for Husky Biz CLI
+ *
+ * Uses Google Application Default Credentials (ADC)
+ * Run: gcloud auth application-default login
+ */
+export declare const EMBEDDING_MODELS: {
+    readonly TEXT_EMBEDDING_004: "text-embedding-004";
+    readonly TEXT_MULTILINGUAL_002: "text-multilingual-embedding-002";
+};
+export interface EmbeddingConfig {
+    projectId: string;
+    location?: string;
+    model?: string;
+}
+export interface EmbeddingResult {
+    values: number[];
+    text: string;
+}
+export declare class EmbeddingService {
+    private projectId;
+    private location;
+    private model;
+    private accessToken;
+    private tokenExpiry;
+    constructor(config: EmbeddingConfig);
+    /**
+     * Create service from Husky config
+     */
+    static fromConfig(): EmbeddingService;
+    /**
+     * Get access token using gcloud CLI
+     */
+    private getAccessToken;
+    /**
+     * Generate embedding for a single text
+     */
+    embed(text: string): Promise<number[]>;
+    /**
+     * Generate embeddings for multiple texts (batch)
+     */
+    embedBatch(texts: string[]): Promise<EmbeddingResult[]>;
+}
+export default EmbeddingService;

package/dist/lib/biz/embeddings.js

@@ -0,0 +1,115 @@
+/**
+ * Vertex AI Embedding Service
+ * Ported from TigerV0 for Husky Biz CLI
+ *
+ * Uses Google Application Default Credentials (ADC)
+ * Run: gcloud auth application-default login
+ */
+import { getConfig } from '../../commands/config.js';
+export const EMBEDDING_MODELS = {
+    TEXT_EMBEDDING_004: 'text-embedding-004',
+    TEXT_MULTILINGUAL_002: 'text-multilingual-embedding-002',
+};
+export class EmbeddingService {
+    projectId;
+    location;
+    model;
+    accessToken = null;
+    tokenExpiry = null;
+    constructor(config) {
+        this.projectId = config.projectId;
+        this.location = config.location || 'europe-west1';
+        this.model = config.model || EMBEDDING_MODELS.TEXT_EMBEDDING_004;
+    }
+    /**
+     * Create service from Husky config
+     */
+    static fromConfig() {
+        const config = getConfig();
+        const embeddingConfig = {
+            projectId: config.gcpProjectId || process.env.GOOGLE_PROJECT_ID || process.env.GCP_PROJECT_ID || '',
+            location: config.gcpLocation || process.env.GOOGLE_LOCATION || 'europe-west1',
+            model: process.env.EMBEDDING_MODEL || EMBEDDING_MODELS.TEXT_EMBEDDING_004,
+        };
+        if (!embeddingConfig.projectId) {
+            throw new Error('Missing GCP Project ID. Configure with:\n' +
+                '  husky config set gcp-project-id <project-id>\n\n' +
+                'Also ensure ADC is set up: gcloud auth application-default login');
+        }
+        return new EmbeddingService(embeddingConfig);
+    }
+    /**
+     * Get access token using gcloud CLI
+     */
+    async getAccessToken() {
+        const now = Date.now();
+        if (this.accessToken && this.tokenExpiry && now < this.tokenExpiry) {
+            return this.accessToken;
+        }
+        // Use gcloud CLI to get access token
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+        try {
+            const { stdout } = await execAsync('gcloud auth print-access-token');
+            this.accessToken = stdout.trim();
+            // Token valid for ~1 hour, refresh after 50 minutes
+            this.tokenExpiry = now + (50 * 60 * 1000);
+            return this.accessToken;
+        }
+        catch (error) {
+            throw new Error('Failed to get GCP access token. Ensure gcloud is installed and run:\n' +
+                '  gcloud auth application-default login');
+        }
+    }
+    /**
+     * Generate embedding for a single text
+     */
+    async embed(text) {
+        const token = await this.getAccessToken();
+        const endpoint = `https://${this.location}-aiplatform.googleapis.com/v1/projects/${this.projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                instances: [{ content: text }],
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Embedding API Error ${response.status}: ${error}`);
+        }
+        const data = await response.json();
+        return data.predictions[0].embeddings.values;
+    }
+    /**
+     * Generate embeddings for multiple texts (batch)
+     */
+    async embedBatch(texts) {
+        const token = await this.getAccessToken();
+        const endpoint = `https://${this.location}-aiplatform.googleapis.com/v1/projects/${this.projectId}/locations/${this.location}/publishers/google/models/${this.model}:predict`;
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                instances: texts.map((text) => ({ content: text })),
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Embedding API Error ${response.status}: ${error}`);
+        }
+        const data = await response.json();
+        return texts.map((text, i) => ({
+            text,
+            values: data.predictions[i].embeddings.values,
+        }));
+    }
+}
+export default EmbeddingService;