orchid-ai 1.0.0

package/dist/server/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/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/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';

package/dist/server/server/server.d.ts

@@ -0,0 +1,32 @@
+import type { CommandConfig, RouteConfig, TrainingCustomData, AIProvider, AIServiceConfig } from '../types/types.js';
+export interface ServerOptions extends AIServiceConfig {
+    port?: number;
+    baseDir?: string;
+    service?: AIProvider;
+    apiKey?: string;
+    customTrainingData?: TrainingCustomData;
+    routes?: (string | RouteConfig)[];
+}
+export interface CommandServer {
+    app: any;
+    start: () => void;
+    stop: () => void;
+    getConfig: () => CommandConfig;
+}
+/**
+ * Helper function to format error messages for user-friendly display
+ */
+export declare function formatErrorForUser(error: Error): {
+    message: string;
+    type: string;
+    retryAfter?: number;
+};
+/**
+ * Setup a command server with training data collection and streaming support.
+ * Works both as a standalone server and as middleware for existing Express apps.
+ */
+export declare function setupCommandServer(options?: ServerOptions): Promise<CommandServer>;
+/**
+ * Create a command configuration by merging training data from multiple sources
+ */
+export declare function createCommandConfig(options: ServerOptions): Promise<CommandConfig>;

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

@@ -0,0 +1,267 @@
+import { OpenAI } from 'openai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import Anthropic from '@anthropic-ai/sdk';
+import { TrainingDataPaths, AIServiceConfig, ImageContent } from '../types/types.js';
+export declare class CommandService {
+    private aiConfig;
+    private verboseLogging;
+    private model;
+    private modelConfig;
+    private usage;
+    constructor(config: AIServiceConfig, verboseLogging?: boolean);
+    private autoConfigureProviders;
+    private log;
+    private handleError;
+    /**
+     * Initialize the service with training data
+     * This must be called before using the service
+     */
+    initialize(): Promise<void>;
+    initializeTrainingData(): Promise<void>;
+    writeConfigToFile(): Promise<void>;
+    writeFailedJsonToFile(failedJson: string, errorMessage: string): Promise<void>;
+    tryPrettifyJson(jsonStr: string): string;
+    /**
+     * Build model configuration with current training data
+     */
+    buildModelConfig(): {
+        claude: {
+            model: string | null | undefined;
+            system: string;
+            max_tokens: number;
+            temperature: number;
+        };
+        openai: {
+            model: string | null | undefined;
+            messages: {
+                role: string;
+                content: string;
+            }[];
+            temperature: number;
+            max_tokens: number;
+        };
+        gemini: {
+            model: string | null | undefined;
+            systemInstruction: string;
+            generationConfig: {
+                temperature: number;
+                maxOutputTokens: number;
+            };
+        };
+    };
+    extractPatterns(data: TrainingDataPaths): Map<string, Set<string>>;
+    updateSystemPrompt(patterns: Map<string, Set<string>>): string;
+    getAvailableModels(): Promise<any[]>;
+    createModelInstance(provider: string, apiKey: string): OpenAI | GoogleGenerativeAI | Anthropic;
+    getModelDisplayName(modelId: string): string;
+    getSingleProviderModels(): Promise<any>;
+    /**
+     * Get complete model state (models, current, capabilities, usage) in one call
+     * This reduces API calls and ensures data consistency
+     */
+    getModelState(): Promise<{
+        models: any[];
+        current: {
+            provider: string;
+            model: string;
+        };
+        capabilities: {
+            supportsImages: string;
+        };
+        usage: {
+            requests: number;
+            totalTokens: number;
+            totalComputeUnits: number;
+            modelSwitches: number;
+            uptime: number;
+            providers: {
+                name: string;
+                requests: number;
+                models: string[];
+            }[];
+        };
+        timestamp: number;
+    }>;
+    /**
+     * Create a model instance for a specific request without changing global state
+     */
+    createModelForRequest(modelSelection: {
+        provider: string;
+        model: string;
+    } | undefined): {
+        model: OpenAI | GoogleGenerativeAI | Anthropic;
+        config: {
+            openai: {
+                model: string;
+                temperature: number;
+                max_tokens: number;
+                messages: {
+                    role: string;
+                    content: string;
+                }[];
+            };
+            claude?: undefined;
+            gemini?: undefined;
+        } | {
+            claude: {
+                model: string;
+                temperature: number;
+                max_tokens: number;
+                system: string;
+                messages: never[];
+            };
+            openai?: undefined;
+            gemini?: undefined;
+        } | {
+            gemini: {
+                model: string;
+                temperature: number;
+                maxOutputTokens: number;
+                systemInstruction: string;
+                generationConfig: {
+                    temperature: number;
+                    maxOutputTokens: number;
+                    candidateCount: number;
+                };
+            };
+            openai?: undefined;
+            claude?: undefined;
+        };
+        provider: string;
+        modelId: string;
+    };
+    /**
+     * Get API key for a specific provider
+     */
+    getApiKeyForProvider(provider: string): string | null | undefined;
+    /**
+     * Build model configuration for a specific request
+     */
+    buildModelConfigForRequest(provider: string, model: string): {
+        openai: {
+            model: string;
+            temperature: number;
+            max_tokens: number;
+            messages: {
+                role: string;
+                content: string;
+            }[];
+        };
+        claude?: undefined;
+        gemini?: undefined;
+    } | {
+        claude: {
+            model: string;
+            temperature: number;
+            max_tokens: number;
+            system: string;
+            messages: never[];
+        };
+        openai?: undefined;
+        gemini?: undefined;
+    } | {
+        gemini: {
+            model: string;
+            temperature: number;
+            maxOutputTokens: number;
+            systemInstruction: string;
+            generationConfig: {
+                temperature: number;
+                maxOutputTokens: number;
+                candidateCount: number;
+            };
+        };
+        openai?: undefined;
+        claude?: undefined;
+    };
+    /**
+     * Get suggestions for a command
+     * @param command - The command to get suggestions for
+     * @param chatHistory - The chat history
+     * @param retryCount - The number of retries
+     * @param chatLevel - The chat level
+     * @param modelSelection - The model selection
+     * @returns The suggestions
+     */
+    getSuggestions(command: string, chatHistory: any[] | undefined, retryCount: number | undefined, chatLevel: 'full' | 'basic' | 'none' | undefined, modelSelection: {
+        provider: string;
+        model: string;
+    } | undefined, context?: string): Promise<Array<{
+        action?: string;
+        path?: string;
+        formState?: Record<string, any>;
+        [key: string]: any;
+    }>>;
+    /**
+     * Check if a response is effectively empty and needs retry
+     */
+    isEmptyResponse(text: string, suggestions?: any[] | null): boolean;
+    /**
+     * Create a retry prompt that encourages more helpful responses
+     */
+    createRetryPrompt(originalCommand: string, retryCount: number): string;
+    streamSuggestions(command: string, userId: string, chatHistory: any[], onData: (data: any) => void, onDone: () => void, onError: (error: Error) => void, images?: any[], retryCount?: number, chatLevel?: 'full' | 'basic' | 'none' | undefined, modelSelection?: {
+        provider: string;
+        model: string;
+        capabilities: {
+            computeWeight: number;
+            imageSupport: boolean;
+        };
+    }, context?: string): Promise<void>;
+    getSuggestionsWithImages(command: string, chatHistory: any[], images: any[], modelSelection?: {
+        provider: string;
+        model: string;
+    } | undefined): Promise<{
+        formState: Record<string, any>;
+        action?: string;
+        actionType: import("../types/types.js").Action;
+        path?: string;
+        queryParams?: Record<string, string>;
+        message?: string;
+        user?: import("../types/types.js").User;
+        initials?: string;
+        color?: string;
+        shortcut?: string;
+        title?: string;
+        description?: string;
+    }[]>;
+    getUsageStats(): {
+        requests: number;
+        totalTokens: number;
+        totalComputeUnits: number;
+        modelSwitches: number;
+        uptime: number;
+        providers: {
+            name: string;
+            requests: number;
+            models: string[];
+        }[];
+    };
+    resetUsageStats(): void;
+    trackRequest(provider: string, tokenCount?: number): void;
+    /**
+     * Helper: Refine fields that require refinement
+     */
+    refineFieldsIfNeeded(suggestions: any, context: any, messages?: any[], provider?: string | null): Promise<any>;
+    /**
+     * Helper: Get raw response content from any provider
+     */
+    getProviderResponse(command: string | ImageContent[], chatHistory: any[] | undefined, messages?: any[], provider?: string | null): Promise<any>;
+    /**
+     * Helper: Process suggestions with full pipeline
+     */
+    processSuggestionsPipeline(suggestions: any[], context: any, messages?: any[], provider?: string | null): Promise<{
+        formState: Record<string, any>;
+        action?: string;
+        actionType: import("../types/types.js").Action;
+        path?: string;
+        queryParams?: Record<string, string>;
+        message?: string;
+        user?: import("../types/types.js").User;
+        initials?: string;
+        color?: string;
+        shortcut?: string;
+        title?: string;
+        description?: string;
+    }[]>;
+}

package/dist/server/server/training-schema.d.ts

@@ -0,0 +1,17 @@
+import type { TrainingConfig } from '../types/types.js';
+/**
+ * Validate training configuration
+ */
+export declare function validateTrainingConfig(config: TrainingConfig): {
+    isValid: boolean;
+    errors: string[];
+};
+/**
+ * Create a normalized training configuration
+ */
+export declare function createTrainingConfig(options?: Partial<TrainingConfig>): TrainingConfig;
+/**
+ * Gets the expected file structure for training data
+ * @returns Expected file structure
+ */
+export declare function getExpectedFileStructure(): Record<string, string>;

package/dist/server/server/training.d.ts

@@ -0,0 +1,231 @@
+import type { TrainingConfig, ProcessedTrainingData } from '../types/types.js';
+interface CollectedFile {
+    filePath: string;
+    path: string;
+    content: any;
+}
+export declare function getTrainingDataConfig(chatLevel?: string): TrainingConfig;
+export declare class CommandTrainingCollector {
+    private rootDir;
+    private config;
+    private verboseLogging;
+    private rules;
+    private structuredData;
+    constructor(rootDir: string, config: TrainingConfig, verboseLogging?: boolean);
+    log(...args: any[]): void;
+    collectTrainingData(): Promise<ProcessedTrainingData>;
+    private collectRawData;
+    private buildStructuredData;
+    private buildDataModels;
+    private buildComponents;
+    private buildNavigation;
+    private buildBusinessRules;
+    private buildExamples;
+    private updateOverview;
+    private generateProviderFormats;
+    private guessEntityFromComponent;
+    private guessEntitiesFromComponent;
+    private extractRouteParams;
+    private guessEntityFromPath;
+    getTrainingConfig(): TrainingConfig;
+    collectFiles(fieldName: string, filePaths?: string[]): Promise<CollectedFile[]>;
+    expandGlobPatterns(patterns: string[]): Promise<string[]>;
+    extractFileInfo(fieldName: string, content: string): {
+        componentName: string | null;
+        props: Array<{
+            interfaceName: string;
+            properties: Array<{
+                name: string;
+                type: string;
+                optional: boolean;
+            }>;
+        }>;
+        state: Array<{
+            type: string;
+            variable: string | null;
+        }>;
+        functions: Array<{
+            name: string;
+            signature: string;
+        }>;
+        routes: string[];
+        formFields: string[];
+        imports: string[];
+        exports: string[];
+        hooks: string[];
+        eventHandlers: string[];
+    } | {
+        modelName: string | null;
+        fields: Array<{
+            name: string;
+            type: string;
+            required: boolean;
+            dataType: string;
+            transform: any;
+            validation: any;
+        }>;
+        indexes: Array<{
+            field: string;
+            direction: string;
+        }>;
+        validations: Array<{
+            field: string;
+            rule: string;
+        }>;
+    } | {
+        definitions: string[];
+        constValues: Array<{
+            name: string;
+            value: any;
+            type: string;
+        }>;
+        enums: Array<{
+            name: string;
+            members: Array<{
+                name: string;
+                value: string;
+            }>;
+        }>;
+        enumValues: string[];
+    } | {
+        types: string[];
+        typeDefinitions: Array<{
+            name: string;
+            definition: string;
+        }>;
+        interfaces: string[];
+        interfaceDefinitions: Array<{
+            name: string;
+            properties: Array<{
+                name: string;
+                type: string;
+                optional: boolean;
+            }>;
+        }>;
+        enums: Array<{
+            name: string;
+            members: Array<{
+                name: string;
+                value: string;
+            }>;
+        }>;
+        enumMembers: string[];
+    } | {
+        content: string;
+    };
+    collectComponents(): Promise<CollectedFile[]>;
+    collectSchemas(): Promise<CollectedFile[]>;
+    collectConstants(): Promise<CollectedFile[]>;
+    collectTypes(): Promise<CollectedFile[]>;
+    extractComponentInfo(content: string): {
+        componentName: string | null;
+        props: Array<{
+            interfaceName: string;
+            properties: Array<{
+                name: string;
+                type: string;
+                optional: boolean;
+            }>;
+        }>;
+        state: Array<{
+            type: string;
+            variable: string | null;
+        }>;
+        functions: Array<{
+            name: string;
+            signature: string;
+        }>;
+        routes: string[];
+        formFields: string[];
+        imports: string[];
+        exports: string[];
+        hooks: string[];
+        eventHandlers: string[];
+    };
+    extractSchemaInfo(content: string): {
+        modelName: string | null;
+        fields: Array<{
+            name: string;
+            type: string;
+            required: boolean;
+            dataType: string;
+            transform: any;
+            validation: any;
+        }>;
+        indexes: Array<{
+            field: string;
+            direction: string;
+        }>;
+        validations: Array<{
+            field: string;
+            rule: string;
+        }>;
+    };
+    extractConstantsInfo(content: string): {
+        definitions: string[];
+        constValues: Array<{
+            name: string;
+            value: any;
+            type: string;
+        }>;
+        enums: Array<{
+            name: string;
+            members: Array<{
+                name: string;
+                value: string;
+            }>;
+        }>;
+        enumValues: string[];
+    };
+    extractTypeInfo(content: string): {
+        types: string[];
+        typeDefinitions: Array<{
+            name: string;
+            definition: string;
+        }>;
+        interfaces: string[];
+        interfaceDefinitions: Array<{
+            name: string;
+            properties: Array<{
+                name: string;
+                type: string;
+                optional: boolean;
+            }>;
+        }>;
+        enums: Array<{
+            name: string;
+            members: Array<{
+                name: string;
+                value: string;
+            }>;
+        }>;
+        enumMembers: string[];
+    };
+    /**
+     * Parse interface properties from a TypeScript interface
+     * @param {string} propertiesText - The properties section of an interface
+     * @returns {Array<{name: string, type: string, optional: boolean}>}
+     */
+    parseInterfaceProperties(propertiesText: string): {
+        name: string;
+        type: string;
+        optional: boolean;
+    }[];
+    /**
+     * Parse enum members from a TypeScript enum
+     * @param {string} membersText - The members section of an enum
+     * @returns {Array<{name: string, value: string}>}
+     */
+    parseEnumMembers(membersText: string): {
+        name: string;
+        value: string;
+    }[];
+    /**
+     * Extract state variable name from useState hook
+     * @param {string} content - File content
+     * @param {number} stateIndex - Index of useState match
+     * @returns {string|null}
+     */
+    extractStateVariable(content: string, stateIndex: number): string | null;
+}
+export {};