orchid-ai 1.0.0

package/dist/server/constants.d.ts

@@ -0,0 +1,353 @@
+import { ChatTheme, CommandTheme, ModelInfo } from './types/types';
+export declare const DEFAULT_CONFIG: {
+    service: "claude";
+    model: string;
+    temperature: number;
+    maxTokens: number;
+    chatLevel: "none";
+    supportsImages: boolean;
+};
+export declare const DEFAULT_MODELS: Record<string, ModelInfo[]>;
+export declare const defaultTheme: CommandTheme;
+export declare const defaultDarkTheme: ChatTheme;
+export declare const defaultLightTheme: ChatTheme;
+export declare const commandTrainingRules: {
+    components: {
+        patterns: {
+            componentName: RegExp;
+            props: RegExp;
+            state: RegExp;
+            functions: RegExp;
+            routes: RegExp;
+            formFields: RegExp;
+            imports: RegExp;
+            exports: RegExp;
+            hooks: RegExp;
+            eventHandlers: RegExp;
+        };
+        importance: string[];
+    };
+    schemas: {
+        patterns: {
+            modelName: RegExp;
+            fields: RegExp;
+            fieldDefinitions: RegExp;
+            indexes: RegExp;
+            indexDefinitions: RegExp;
+            validations: RegExp;
+            validationRules: RegExp;
+        };
+        importance: string[];
+    };
+    constants: {
+        patterns: {
+            definitions: RegExp;
+            constValues: RegExp;
+            enums: RegExp;
+            enumValues: RegExp;
+            arrayConstants: RegExp;
+            objectConstants: RegExp;
+        };
+        importance: string[];
+    };
+    types: {
+        patterns: {
+            types: RegExp;
+            typeDefinitions: RegExp;
+            interfaces: RegExp;
+            interfaceDefinitions: RegExp;
+            enums: RegExp;
+            enumMembers: RegExp;
+            generics: RegExp;
+            unionTypes: RegExp;
+            optionalFields: RegExp;
+        };
+        importance: string[];
+    };
+    dataTypes: {
+        date: {
+            pattern: RegExp;
+            transform: (value: any) => any;
+            validation: (value: any) => boolean;
+        };
+        number: {
+            pattern: RegExp;
+            transform: (value: any) => number;
+            validation: (value: any) => boolean;
+        };
+        boolean: {
+            pattern: RegExp;
+            transform: (value: any) => boolean;
+            validation: (value: any) => value is boolean;
+        };
+        string: {
+            pattern: RegExp;
+            transform: (value: any) => string;
+            validation: (value: any) => value is string;
+        };
+        array: {
+            pattern: RegExp;
+            transform: (value: any) => any[];
+            validation: (value: any) => value is any[];
+        };
+        object: {
+            pattern: RegExp;
+            transform: (value: any) => any;
+            validation: (value: any) => boolean;
+        };
+    };
+    dataTypeImportance: string[];
+};
+/**
+ * Base training data for the command service.
+ *
+ * NOTE: You should customize the following for your project:
+ *   - components: List all relevant React component files.
+ *   - schemas: List all Monastery schema files.
+ *   - constants: List all constants files.
+ *   - types: List all TypeScript type files.
+ *   - options: Define all field options and refinement logic for your domain.
+ *   - _paths: Metadata specifying which fields contain file paths (used by collector).
+ *
+ * The collector will extract structured data including:
+ *   - Component names, props, state, functions, form fields
+ *   - Schema field definitions with types and validations
+ *   - Constant values and enum members
+ *   - TypeScript interfaces and type definitions
+ */
+export declare const baseTrainingData: {
+    /**
+     * List of React component file paths used for context.
+     * The collector will extract: component names, props, state, functions, form fields, imports, hooks
+     * @type {string[]}
+     */
+    components: never[];
+    /**
+     * List of Monastery schema file paths.
+     * The collector will extract: model names, field definitions, indexes, validations
+     * @type {string[]}
+     */
+    schemas: never[];
+    /**
+     * List of constants file paths.
+     * The collector will extract: constant definitions, values, enums
+     * @type {string[]}
+     */
+    constants: never[];
+    /**
+     * List of TypeScript type file paths.
+     * The collector will extract: type definitions, interfaces, enums
+     * @type {string[]}
+     */
+    types: never[];
+    /**
+     * Manual route definitions with descriptions.
+     * Define all available routes with clear descriptions for the AI to understand.
+     * Format: { path: string, title: string, description?: string }
+     * @type {Array<{path: string, title: string, description?: string}>}
+     */
+    routes: never[];
+    /**
+     * Field options and refinement logic. Customize for your domain fields.
+     * The AI will use these to understand field values and validation rules.
+     * @type {Object}
+     */
+    options: {};
+    /**
+     * Metadata specifying which fields contain file paths for the collector.
+     * The collector will automatically read and process these fields.
+     * Note: 'routes' is now handled manually - no automatic extraction.
+     * @type {string[]}
+     */
+    _paths: never[];
+    /**
+     * Action types.
+     * The AI will use these to understand the user's input
+     * and return the correct suggestions for icon display
+     * @type {Object}
+     */
+    actionTypes: {
+        type: string;
+        description: string;
+    }[];
+};
+/**
+ * Instructions for a fully conversational AI assistant.
+ * Always provides chatty, helpful responses regardless of context.
+ */
+export declare const fullChatInstructions: string;
+/**
+ * Instructions for a basic conversational AI assistant.
+ * Balances being helpful with being concise, focusing on essential help and actions.
+ */
+export declare const basicChatInstructions: string;
+/**
+ * Instructions for a functional, JSON-only AI assistant.
+ * Provides only JSON responses with no explanations or commentary.
+ */
+export declare const noneChatInstructions: string;
+/**
+ * Structured training data format optimized for AI models
+ * Organizes information hierarchically with clear relationships
+ */
+export declare const structuredTrainingFormat: {
+    /**
+     * Application Overview - High-level context for the AI
+     */
+    overview: {
+        domain: string;
+        purpose: string;
+        architecture: string;
+        primaryEntities: string[];
+        commonActions: string[];
+    };
+    /**
+     * Component Hierarchy - Organized by functionality
+     */
+    components: {
+        pages: Array<{
+            name: string;
+            path: string;
+            purpose: string;
+            mainActions: string[];
+            relatedEntities: string[];
+        }>;
+        forms: Array<{
+            name: string;
+            purpose: string;
+            fields: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                validation?: string;
+            }>;
+            actions: string[];
+            relatedEntity: string;
+        }>;
+        ui: Array<{
+            name: string;
+            purpose: string;
+            props: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+            }>;
+        }>;
+    };
+    /**
+     * Data Models - Structured with relationships
+     */
+    dataModels: {
+        entities: Array<{
+            name: string;
+            purpose: string;
+            fields: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+                validation?: string;
+                options?: string[];
+            }>;
+            relationships: Array<{
+                type: "hasMany" | "belongsTo" | "hasOne";
+                entity: string;
+                description: string;
+            }>;
+            commonActions: string[];
+        }>;
+        enums: Array<{
+            name: string;
+            purpose: string;
+            values: Array<{
+                key: string;
+                value: string;
+                description?: string;
+            }>;
+        }>;
+    };
+    /**
+     * Navigation & Routes - Organized by user flow
+     */
+    navigation: {
+        routes: Array<{
+            path: string;
+            name: string;
+            purpose: string;
+            requiredParams?: string[];
+            relatedEntity?: string;
+            commonActions: string[];
+        }>;
+        workflows: Array<{
+            name: string;
+            description: string;
+            steps: Array<{
+                action: string;
+                route: string;
+                description: string;
+            }>;
+        }>;
+    };
+    /**
+     * Business Rules - Context for decision making
+     */
+    businessRules: {
+        validation: Array<{
+            field: string;
+            rule: string;
+            message: string;
+            context: string;
+        }>;
+        workflows: Array<{
+            trigger: string;
+            conditions: string[];
+            actions: string[];
+            description: string;
+        }>;
+        permissions: Array<{
+            action: string;
+            entity: string;
+            conditions: string[];
+            description: string;
+        }>;
+    };
+    /**
+     * Examples - Concrete usage patterns
+     */
+    examples: {
+        commonTasks: Array<{
+            userIntent: string;
+            expectedAction: string;
+            formData?: Record<string, any>;
+            route?: string;
+            description: string;
+        }>;
+        fieldMappings: Array<{
+            userInput: string;
+            fieldName: string;
+            processedValue: any;
+            validation?: string;
+        }>;
+    };
+};
+/**
+ * Provider-specific training data formatters
+ * These functions format the structured training data in optimal ways for each AI provider
+ */
+export declare const trainingDataFormatters: {
+    /**
+     * Claude-optimized format: Structured markdown with clear sections
+     * Claude performs best with clear hierarchical markdown and explicit structure
+     */
+    claude: (data: typeof structuredTrainingFormat) => string;
+    /**
+     * GPT-4-optimized format: Structured with clear hierarchy and consistent formatting
+     * OpenAI models prefer clear structure with consistent patterns
+     */
+    openai: (data: typeof structuredTrainingFormat) => string;
+    /**
+     * Gemini-optimized format: JSON structure with nested relationships
+     * Gemini models excel at processing structured JSON data with clear relationships
+     */
+    gemini: (data: typeof structuredTrainingFormat) => string;
+};

package/dist/server/contextual-service.d.ts

@@ -0,0 +1,59 @@
+import type { ContextualServiceConfig, ContextualRequest } from '../types/types.js';
+export declare class ContextualCommandService {
+    private config;
+    private verboseLogging;
+    private usage;
+    constructor(config: ContextualServiceConfig);
+    private autoConfigureProviders;
+    private log;
+    private handleError;
+    /**
+     * Build a focused system prompt based on schema and chat level
+     */
+    private buildContextualSystemPrompt;
+    /**
+     * Format schema fields into readable descriptions
+     */
+    private formatSchemaFields;
+    /**
+     * Create a model instance for a specific request
+     */
+    private createModelForRequest;
+    private createModelInstance;
+    private getApiKeyForProvider;
+    /**
+     * Stream suggestions with contextual schema information
+     */
+    streamSuggestions(request: ContextualRequest, onData: (data: any) => void, onDone: () => void, onError: (error: Error) => void): Promise<void>;
+    /**
+     * Get non-streaming suggestions
+     */
+    getSuggestions(request: ContextualRequest): Promise<any[]>;
+    /**
+     * Get available models
+     */
+    getAvailableModels(): Promise<{
+        id: string;
+        name: string;
+        provider: string;
+        available: boolean;
+    }[]>;
+    /**
+     * Get usage statistics
+     */
+    getUsageStats(): {
+        requests: number;
+        totalTokens: number;
+        totalComputeUnits: number;
+        providers: {
+            name: string;
+            requests: number;
+            computeUnits: number;
+            models: string[];
+        }[];
+    };
+    /**
+     * Track request for usage stats
+     */
+    private trackRequest;
+}

package/dist/server/document-processor.d.ts

@@ -0,0 +1,60 @@
+export interface ProcessedFile {
+    name: string;
+    type: string;
+    size: number;
+    content: string;
+    isImage: boolean;
+    originalData?: string;
+    fileData?: string;
+    metadata?: {
+        dimensions?: {
+            width: number;
+            height: number;
+        };
+        encoding?: string;
+        pages?: number;
+        sheets?: string[];
+        rows?: number;
+        columns?: string[];
+    };
+}
+export declare class DocumentProcessor {
+    /**
+     * Process a single file and extract its content
+     */
+    static processFile(file: {
+        name: string;
+        type: string;
+        size: number;
+        data: string;
+    }, aiService?: string): Promise<ProcessedFile>;
+    /**
+     * Process multiple files and return both processed files and image data for AI
+     */
+    static processFiles(files: Array<{
+        name: string;
+        type: string;
+        size: number;
+        data: string;
+    }>, aiService?: string): Promise<{
+        processedFiles: ProcessedFile[];
+        imageData: Array<{
+            data: string;
+            type: string;
+            name: string;
+        }>;
+        fileData: string[];
+        textContent: string;
+    }>;
+    private static getSupportedFormats;
+    private static processImage;
+    private static isImageFile;
+    private static processPDF;
+    private static processTextFile;
+    private static processRTF;
+    private static processCSV;
+    private static formatFileSize;
+    private static processJSON;
+    private static processXML;
+    private static isValidUTF8Text;
+}

package/dist/server/hooks/useAiMerge.d.ts

@@ -0,0 +1,20 @@
+import { MergeConfig } from '../utils';
+interface Options<T> {
+    ai?: Partial<T>;
+    draft: T;
+    onMerged: (next: T) => void;
+    config?: MergeConfig<T>;
+}
+/**
+ * React hook that merges an AI-generated payload into local form state.
+ *
+ * Usage:
+ *   const { pending, applyPending } = useAiMerge({ ai, draft, onMerged })
+ *   <WarningModal isOpen={!!pending} onConfirm={applyPending} />
+ */
+export declare function useAiMerge<T>({ ai, draft, onMerged, config }: Options<T>): {
+    pending: Partial<T> | null;
+    applyPending: () => void;
+    clearPending: () => void;
+};
+export {};

package/dist/server/hooks/useModelSwitcher.d.ts

@@ -0,0 +1,65 @@
+import { ModelInfo } from '../types/types';
+interface CurrentModel {
+    provider: string;
+    model: string;
+}
+interface ModelCapabilities {
+    supportsImages: boolean;
+    computeWeight?: number;
+}
+interface UsageStats {
+    requests: number;
+    totalTokens: number;
+    totalComputeUnits: number;
+    modelSwitches: number;
+    uptime: number;
+    providers: Array<{
+        name: string;
+        requests: number;
+        computeUnits: number;
+        models: string[];
+    }>;
+    currentProvider: string;
+    currentModel: string;
+}
+interface UseModelSwitcherOptions {
+    initialProvider?: string;
+    initialModel?: string;
+    customModels?: Record<string, ModelInfo[]>;
+}
+export declare function useModelSwitcher({ initialProvider, initialModel, customModels, }?: UseModelSwitcherOptions): {
+    models: ModelInfo[];
+    modelsByProvider: Record<string, ModelInfo[]>;
+    currentModel: CurrentModel;
+    currentCapabilities: ModelCapabilities;
+    usageStats: UsageStats;
+    isLoading: boolean;
+    error: null;
+    switchModel: (model: string, provider?: string) => {
+        success: boolean;
+        current: {
+            provider: string;
+            model: string;
+        };
+    };
+    trackUsage: (tokens: number, computeUnits: number) => void;
+    resetUsageStats: () => void;
+    getCurrentModelInfo: () => {
+        provider: string;
+        model: string;
+        capabilities: ModelCapabilities;
+    };
+    modelState: {
+        models: ModelInfo[];
+        current: CurrentModel;
+        capabilities: ModelCapabilities;
+        usage: UsageStats;
+        timestamp: number;
+    };
+    fetchModelState: () => Promise<void>;
+    fetchModels: () => Promise<void>;
+    fetchUsageStats: () => Promise<void>;
+    fetchCurrentCapabilities: () => Promise<void>;
+    integrationMode: "local";
+};
+export {};

package/dist/server/hooks/useStreamingAI.d.ts

@@ -0,0 +1,29 @@
+import { ChatMessage, ModelCapabilities, ServerConfig } from '../types/types';
+interface ModelSelection {
+    provider: string;
+    model: string;
+    capabilities: ModelCapabilities;
+}
+export declare function useStreamingAI({ userId, serverConfig, formData, chats: externalChats, setChats: externalSetChats, currentChatId: externalCurrentChatId, setCurrentChatId: externalSetCurrentChatId, modelSelection, onUsageTracked, chatLevel, additionalContext, verbose, }: {
+    userId: string;
+    serverConfig?: ServerConfig;
+    formData?: Record<string, unknown>;
+    chats?: Record<string, ChatMessage[]>;
+    setChats?: React.Dispatch<React.SetStateAction<Record<string, ChatMessage[]>>>;
+    currentChatId?: string;
+    setCurrentChatId?: React.Dispatch<React.SetStateAction<string>>;
+    modelSelection?: ModelSelection;
+    onUsageTracked?: (tokens: number, computeUnits: number) => void;
+    chatLevel?: 'full' | 'basic' | 'none';
+    additionalContext?: string | Record<string, unknown>;
+    verbose?: boolean;
+}): {
+    chat: ChatMessage[];
+    chats: Record<string, ChatMessage[]>;
+    currentChatId: string;
+    isLoading: boolean;
+    sendQuery: (query: string, files?: File[], context?: string) => void;
+    newChat: () => void;
+    switchChat: (chatId: string) => void;
+};
+export {};

package/dist/server/hooks/useSuggestions.d.ts

@@ -0,0 +1,48 @@
+import { CommandSuggestion, ServerConfig } from '../types/types';
+interface UseSuggestionsProps {
+    userId: string;
+    formData?: Record<string, unknown>;
+    serverConfig?: ServerConfig;
+    debounceMs?: number;
+    maxSuggestions?: number;
+    chatLevel?: 'none' | 'basic' | 'full';
+    modelSelection?: {
+        provider: string;
+        model: string;
+        capabilities: {
+            supportsImages: boolean;
+            computeWeight: number;
+        };
+    };
+    onUsageTracked?: (tokens: number, computeUnits: number) => void;
+    context?: string;
+}
+interface UseSuggestionsReturn {
+    suggestions: CommandSuggestion[];
+    isLoading: boolean;
+    error: string | null;
+    getSuggestions: (query: string, additionalContext?: string) => Promise<CommandSuggestion[] | Error>;
+    clearSuggestions: () => void;
+}
+/**
+ * Hook for getting AI suggestions based on a query
+ *
+ * @param userId - User ID for the suggestion request
+ * @param formData - Current form data context
+ * @param serverConfig - Server configuration
+ * @param debounceMs - Debounce delay in milliseconds (default: 300)
+ * @param maxSuggestions - Maximum number of suggestions to return (default: 10)
+ * @param chatLevel - Chat level to send to the server (default: 'none')
+ * @returns Object containing suggestions, loading state, error state, and control functions
+ */
+export declare function useSuggestions({ userId, formData, serverConfig, debounceMs, maxSuggestions, chatLevel, // <-- default to 'none'
+modelSelection, onUsageTracked, context, }: UseSuggestionsProps): UseSuggestionsReturn;
+/**
+ * Hook for getting suggestions with automatic debouncing
+ *
+ * @param query - The search query
+ * @param options - Configuration options
+ * @returns Object containing suggestions, loading state, and error state
+ */
+export declare function useDebouncedSuggestions(query: string, options: UseSuggestionsProps): Omit<UseSuggestionsReturn, 'getSuggestions' | 'clearSuggestions'>;
+export {};

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+import type { TrainingConfig, ServerOptions, AIProvider, CommandServer, ContextualServiceConfig, ContextualRequest, SchemaDefinition, SchemaProperty } from '../types/types.js';
+export type { ServerOptions, CommandServer, TrainingConfig, AIProvider, ContextualServiceConfig, ContextualRequest, SchemaDefinition, SchemaProperty, };
+export { setupCommandServer, createCommandConfig, formatErrorForUser, } from './server';
+export { CommandService, } from './service';
+export { ContextualCommandService, } from './contextual-service';
+export { getTrainingDataConfig, CommandTrainingCollector, } from './training';
+export { createTrainingConfig, validateTrainingConfig, getExpectedFileStructure, } from './training-schema';