@qwanyx/stack 0.2.6 → 0.2.9

package/dist/api/client.d.ts

@@ -0,0 +1,53 @@
+import type { ApiConfig, QueryParams } from '../types';
+/**
+ * Generic API Client
+ * Framework-agnostic HTTP client for any API
+ */
+export declare class ApiClient {
+    private config;
+    constructor(config: ApiConfig);
+    /**
+     * Build query string from params
+     */
+    private buildQueryString;
+    /**
+     * Make HTTP request
+     */
+    private request;
+    /**
+     * GET request
+     */
+    get<T = any>(endpoint: string, params?: QueryParams): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T = any>(endpoint: string, body?: any, params?: QueryParams): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T = any>(endpoint: string, body?: any, params?: QueryParams): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T = any>(endpoint: string, body?: any, params?: QueryParams): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T = any>(endpoint: string, params?: QueryParams): Promise<T>;
+    /**
+     * Update base URL
+     */
+    setBaseUrl(baseUrl: string): void;
+    /**
+     * Get current base URL
+     */
+    getBaseUrl(): string;
+}
+/**
+ * Initialize the API client
+ */
+export declare function initializeApiClient(config: ApiConfig): ApiClient;
+/**
+ * Get the API client instance
+ */
+export declare function getApiClient(): ApiClient;

package/dist/auth/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Generic authentication manager
+ * Handles token storage and retrieval
+ */
+export declare class AuthManager {
+    /**
+     * Store authentication token
+     */
+    static setToken(token: string): void;
+    /**
+     * Get authentication token
+     */
+    static getToken(): string | null;
+    /**
+     * Remove authentication token
+     */
+    static clearToken(): void;
+    /**
+     * Store refresh token
+     */
+    static setRefreshToken(token: string): void;
+    /**
+     * Get refresh token
+     */
+    static getRefreshToken(): string | null;
+    /**
+     * Check if user is authenticated
+     */
+    static isAuthenticated(): boolean;
+    /**
+     * Get authorization header
+     */
+    static getAuthHeader(): Record<string, string>;
+}

package/dist/client/GraphClient.d.ts

@@ -0,0 +1,137 @@
+/**
+ * GraphClient - Backend Communication Layer
+ *
+ * Provides a type-safe interface to the qwanyx-brain SPU backend.
+ * All operations communicate through the unified `/spu/invoke` endpoint.
+ */
+import type { GraphNode, GraphEdge, GraphClientConfig } from '../types';
+export declare class GraphClient {
+    private config;
+    constructor(config: GraphClientConfig);
+    /**
+     * Call the Graph coprocessor
+     */
+    private callGraph;
+    /**
+     * Get auth token from localStorage (browser) or return empty string
+     */
+    private getToken;
+    /**
+     * Get children nodes
+     */
+    getChildren(parentId?: string): Promise<GraphNode[]>;
+    /**
+     * Get a specific node by ID
+     */
+    getNode(nodeId: string): Promise<GraphNode | null>;
+    /**
+     * Add a new node
+     */
+    addNode(node: Partial<GraphNode> & {
+        p?: string;
+        type: string;
+    }): Promise<GraphNode>;
+    /**
+     * Update an existing node
+     */
+    updateNode(nodeId: string, updates: Partial<GraphNode>): Promise<GraphNode>;
+    /**
+     * Delete a node
+     */
+    deleteNode(nodeId: string, cascade?: boolean): Promise<boolean>;
+    /**
+     * Get children with edges (supports different display modes)
+     */
+    getChildrenWithEdges(nodeId?: string, displayMode?: 'children' | 'edges' | 'both', edgeType?: string, nodeType?: string): Promise<GraphNode[]>;
+    /**
+     * Add an edge between two nodes
+     */
+    addEdge(sourceId: string | null, targetId: string, edgeType?: string, data?: Record<string, any>): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Delete an edge
+     */
+    deleteEdge(sourceId: string | null, targetId: string, edgeType?: string): Promise<{
+        deleted: boolean;
+        count: number;
+    }>;
+    /**
+     * Get edges from a source node
+     * @param sourceId - Source node ID (null for edges without source)
+     * @param edgeType - Optional edge type filter
+     * @param targetId - Optional target node ID for reverse lookups
+     */
+    getEdges(sourceId: string | null, edgeType?: string, targetId?: string): Promise<GraphEdge[]>;
+    /**
+     * Get ancestors of a node (path from root to node)
+     */
+    getAncestors(nodeId: string): Promise<GraphNode[]>;
+    /**
+     * Get tree structure starting from a root
+     */
+    getTree(rootId?: string, maxDepth?: number): Promise<any>;
+    /**
+     * Move a node to a new parent
+     */
+    moveNode(nodeId: string, newParentId?: string): Promise<GraphNode>;
+    /**
+     * Search nodes by query
+     */
+    searchNodes(query: string, type?: string): Promise<GraphNode[]>;
+    /**
+     * Get all nodes of a specific type
+     */
+    getNodesByType(type: string): Promise<GraphNode[]>;
+    /**
+     * Options for file upload
+     */
+    private defaultUploadOptions;
+    /**
+     * Convert File to base64 string
+     */
+    private fileToBase64;
+    /**
+     * Resize an image file if it exceeds maxDimension
+     * Returns the original file if not an image or no resize needed
+     */
+    private resizeImage;
+    /**
+     * Upload a file to a node
+     * @param nodeId - The node to attach the file to
+     * @param filename - The filename to use
+     * @param file - The File object to upload
+     * @param options - Upload options (maxSizeMB, maxImageDimension, imageQuality)
+     */
+    uploadFile(nodeId: string, filename: string, file: File, options?: {
+        maxSizeMB?: number;
+        maxImageDimension?: number;
+        imageQuality?: number;
+    }): Promise<{
+        success: boolean;
+        path?: string;
+        error?: string;
+    }>;
+    /**
+     * List files attached to a node
+     * @param nodeId - The node to list files for
+     */
+    listFiles(nodeId: string): Promise<{
+        filename: string;
+        path: string;
+    }[]>;
+    /**
+     * Delete a file from a node
+     * @param nodeId - The node the file belongs to
+     * @param filename - The filename to delete
+     */
+    deleteFile(nodeId: string, filename: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Get the URL for a file
+     * @param nodeId - The node the file belongs to
+     * @param filename - The filename
+     */
+    getFileUrl(nodeId: string, filename: string): string;
+}

package/dist/client/MailClient.d.ts

@@ -0,0 +1,114 @@
+/**
+ * MailClient - Email Communication Layer
+ *
+ * Provides a type-safe interface to the mail coprocessor in qwanyx-brain.
+ * Handles email settings (with encrypted passwords) and IMAP operations.
+ */
+import type { MailClientConfig, MailAccount, MailListResult, ImapResponse, FolderInfo } from '../types';
+export declare class MailClient {
+    private config;
+    constructor(config: MailClientConfig);
+    /**
+     * Call a coprocessor (default: mail)
+     */
+    private callCoprocessor;
+    /**
+     * Call the Mail coprocessor (IMAP operations)
+     */
+    private callMail;
+    /**
+     * Call the Email coprocessor (SMTP operations)
+     */
+    private callEmail;
+    /**
+     * Get auth token from localStorage (browser) or return empty string
+     */
+    private getToken;
+    /**
+     * Get email settings with decrypted passwords
+     */
+    getSettings(): Promise<{
+        accounts: MailAccount[];
+    }>;
+    /**
+     * Save email settings (passwords encrypted server-side)
+     */
+    saveSettings(accounts: MailAccount[]): Promise<void>;
+    /**
+     * List emails from IMAP folder
+     * @param accountId - Account to use (defaults to first account)
+     * @param limit - Max emails to fetch
+     * @param folder - IMAP folder (default: INBOX). Gmail categories: CATEGORY_SOCIAL, CATEGORY_PROMOTIONS, CATEGORY_UPDATES, CATEGORY_FORUMS
+     */
+    listEmails(accountId?: string, limit?: number, folder?: string): Promise<MailListResult>;
+    /**
+     * Delete emails by UID
+     */
+    deleteEmails(accountId: string, uids: number[], expunge?: boolean): Promise<{
+        success: boolean;
+        deleted: number;
+    }>;
+    /**
+     * Execute raw IMAP commands - thin proxy for stack-side logic
+     * Commands are strings like: "SELECT INBOX", "UID STORE 123 +FLAGS (\\Deleted)", "EXPUNGE"
+     */
+    imapExec(accountId: string, commands: string[]): Promise<{
+        success: boolean;
+        responses: ImapResponse[];
+    }>;
+    /**
+     * Move emails to trash (soft delete)
+     * Tries multiple folder names for Gmail locales
+     */
+    trashEmails(accountId: string, uids: number[]): Promise<{
+        success: boolean;
+        moved: number;
+    }>;
+    /**
+     * Archive emails (remove from inbox, keep in All Mail)
+     */
+    archiveEmails(accountId: string, uids: number[]): Promise<{
+        success: boolean;
+        archived: number;
+    }>;
+    /**
+     * List available folders
+     */
+    listFolders(accountId: string): Promise<{
+        success: boolean;
+        folders: FolderInfo[];
+    }>;
+    /**
+     * Get a single email by UID with full body content
+     */
+    getEmail(accountId: string, uid: number): Promise<{
+        uid: number;
+        from: string;
+        subject: string;
+        date: string;
+        body: string;
+        seen: boolean;
+    } | null>;
+    /**
+     * Send an email via SMTP
+     * Uses the email coprocessor which handles SMTP configuration
+     */
+    sendMail(options: {
+        to: string | string[];
+        subject: string;
+        body: string;
+        html?: string;
+        from?: string;
+        smtpConfig?: {
+            host: string;
+            port: number;
+            username: string;
+            password: string;
+        };
+    }): Promise<{
+        sent: boolean;
+        message_id?: string;
+        timestamp?: string;
+        error?: string;
+    }>;
+}

package/dist/components/AnimatedCardFlip.d.ts

@@ -0,0 +1,19 @@
+export interface AnimatedCardFlipNode {
+    _id: string;
+    type: string;
+    title: string;
+    data: {
+        name: string;
+        image: string;
+    };
+}
+export interface AnimatedCardFlipProps {
+    nodes: AnimatedCardFlipNode[];
+    cardCount?: number;
+    minInterval?: number;
+    maxInterval?: number;
+    onCardClick?: (node: AnimatedCardFlipNode) => void;
+    cardSize?: 'small' | 'medium' | 'large';
+    className?: string;
+}
+export declare function AnimatedCardFlip({ nodes, cardCount, minInterval, maxInterval, onCardClick, cardSize, className }: AnimatedCardFlipProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Card.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Default Card Component for Stack list items
+ * Generic design that works with any data type
+ */
+export interface CardProps<T = any> {
+    item: T;
+    onClick?: () => void;
+    title?: (item: T) => string;
+    subtitle?: (item: T) => string;
+    image?: (item: T) => string | undefined;
+    badge?: (item: T) => string | undefined;
+}
+export declare function Card<T = any>({ item, onClick, title, subtitle, image, badge, }: CardProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/Detail.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Default Detail View Component
+ * Generic detail view for any item
+ */
+export interface DetailProps<T = any> {
+    item: T | null;
+    onClose?: () => void;
+    title?: (item: T) => string;
+    image?: (item: T) => string | undefined;
+    fields?: Array<{
+        label: string;
+        value: (item: T) => any;
+    }>;
+}
+export declare function Detail<T = any>({ item, onClose, title, image, fields, }: DetailProps<T>): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Mail.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Mail Component
+ * Smart email list with selection, actions, and detail view
+ */
+import React from 'react';
+export interface EmailMessage {
+    uid: number;
+    subject: string;
+    from: string;
+    date: string;
+    seen: boolean;
+}
+export interface MailProps {
+    baseUrl: string;
+    systemId: string;
+    accountId: string;
+    limit?: number;
+    folder?: string;
+    selectable?: boolean;
+    showDetail?: boolean;
+    emptyMessage?: string;
+    autoLoad?: boolean;
+    onSelect?: (email: EmailMessage) => void;
+    onSelectionChange?: (uids: number[]) => void;
+    onDelete?: (uids: number[]) => void;
+    onError?: (error: Error) => void;
+    onLoad?: (emails: EmailMessage[]) => void;
+    renderItem?: (email: EmailMessage, selected: boolean) => React.ReactNode;
+    renderDetail?: (email: EmailMessage) => React.ReactNode;
+    renderActions?: (selectedUids: number[], actions: MailActions) => React.ReactNode;
+    renderEmpty?: () => React.ReactNode;
+    renderLoading?: () => React.ReactNode;
+    theme?: MailTheme;
+}
+export interface MailTheme {
+    background?: string;
+    cardBackground?: string;
+    selectedBackground?: string;
+    unreadBackground?: string;
+    text?: string;
+    textSecondary?: string;
+    border?: string;
+    primary?: string;
+    danger?: string;
+}
+export interface MailActions {
+    delete: () => Promise<void>;
+    archive: () => Promise<void>;
+    refresh: () => Promise<void>;
+    selectAll: () => void;
+    clearSelection: () => void;
+}
+export declare function Mail({ baseUrl, systemId, accountId, limit, folder, selectable, showDetail, emptyMessage, autoLoad, onSelect, onSelectionChange, onDelete, onError, onLoad, renderItem, renderDetail, renderActions, renderEmpty, renderLoading, theme: themeProp, }: MailProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Stack.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Stack Component
+ * Apple/Superhuman inspired clean design
+ */
+import React from 'react';
+import type { QueryParams } from '../types';
+export interface StackProps<T = any> {
+    endpoint: string;
+    params?: QueryParams;
+    layout?: 'list' | 'grid' | 'masonry';
+    title?: string;
+    emptyMessage?: string;
+    renderItem?: (item: T, index: number) => React.ReactNode;
+    keyExtractor?: (item: T, index: number) => string;
+    searchable?: boolean;
+    searchFields?: (keyof T)[];
+    searchPlaceholder?: string;
+    filters?: Array<{
+        field: keyof T;
+        label: string;
+        options?: Array<{
+            value: any;
+            label: string;
+        }>;
+    }>;
+    pageSize?: number;
+    onItemClick?: (item: T) => void;
+    onRefresh?: () => void;
+    theme?: {
+        background?: string;
+        cardBackground?: string;
+        text?: string;
+        textSecondary?: string;
+        border?: string;
+        primary?: string;
+    };
+}
+export declare function Stack<T = any>({ endpoint, params, layout, title, emptyMessage, renderItem, keyExtractor, searchable, searchFields, searchPlaceholder, filters, pageSize, onItemClick, onRefresh, theme, }: StackProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/hooks/useMutation.d.ts

@@ -0,0 +1,16 @@
+import type { HttpMethod } from '../types';
+export interface UseMutationOptions<TData, TVariables> {
+    onSuccess?: (data: TData, variables: TVariables) => void;
+    onError?: (error: Error, variables: TVariables) => void;
+}
+export interface UseMutationResult<TData, TVariables> {
+    data: TData | null;
+    loading: boolean;
+    error: Error | null;
+    mutate: (variables: TVariables) => Promise<TData | null>;
+    reset: () => void;
+}
+/**
+ * Generic hook for mutations (POST, PUT, PATCH, DELETE)
+ */
+export declare function useMutation<TData = any, TVariables = any>(endpoint: string, method?: HttpMethod, options?: UseMutationOptions<TData, TVariables>): UseMutationResult<TData, TVariables>;

package/dist/hooks/useQuery.d.ts

@@ -0,0 +1,18 @@
+import type { QueryParams } from '../types';
+export interface UseQueryOptions<T> {
+    enabled?: boolean;
+    refetchOnMount?: boolean;
+    onSuccess?: (data: T) => void;
+    onError?: (error: Error) => void;
+}
+export interface UseQueryResult<T> {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Generic hook for fetching data
+ * Similar to React Query but simpler
+ */
+export declare function useQuery<T = any>(endpoint: string, params?: QueryParams, options?: UseQueryOptions<T>): UseQueryResult<T>;