orchid-ai 1.0.0

package/dist/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 {};

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

@@ -0,0 +1,481 @@
+export interface CommandSuggestion {
+    action?: string;
+    actionType: Action;
+    path?: string;
+    queryParams?: Record<string, string>;
+    formState?: Record<string, unknown>;
+    message?: string;
+    user?: User;
+    initials?: string;
+    color?: string;
+    shortcut?: string;
+    title?: string;
+    description?: string;
+}
+export interface CommandPopupProps {
+    isOpen: boolean;
+    onClose: () => void;
+    userId: string;
+    setFormState: (state: Record<string, unknown>) => void;
+}
+export interface User {
+    id: string;
+    name: string;
+    email: string;
+    initials: string;
+    color: string;
+}
+export interface CommandTheme {
+    primary: string;
+    primaryHover: string;
+    primaryLight: string;
+    secondary: string;
+    secondaryHover: string;
+    background: string;
+    backgroundSecondary: string;
+    backgroundTertiary: string;
+    textPrimary: string;
+    textSecondary: string;
+    textTertiary: string;
+    textInverse: string;
+    borderPrimary: string;
+    borderSecondary: string;
+    success: string;
+    warning: string;
+    error: string;
+    info: string;
+}
+export interface ChatTheme {
+    colors: {
+        primary: {
+            50: string;
+            100: string;
+            400: string;
+            500: string;
+            600: string;
+            700: string;
+            800: string;
+            900: string;
+        };
+        background: {
+            primary: string;
+            secondary: string;
+            tertiary: string;
+        };
+        text: {
+            primary: string;
+            secondary: string;
+            tertiary: string;
+            inverse: string;
+        };
+        border: {
+            primary: string;
+            secondary: string;
+        };
+        surface: {
+            primary: string;
+            secondary: string;
+            tertiary: string;
+            elevated: string;
+        };
+        state: {
+            error: {
+                background: string;
+                border: string;
+                text: string;
+            };
+            warning: {
+                background: string;
+                border: string;
+                text: string;
+            };
+            success: {
+                background: string;
+                border: string;
+                text: string;
+            };
+        };
+    };
+    spacing: {
+        xs: string;
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+    borderRadius: {
+        sm: string;
+        md: string;
+        lg: string;
+        full: string;
+    };
+    shadows: {
+        sm: string;
+        md: string;
+        lg: string;
+        xl: string;
+    };
+}
+export type AIProvider = 'openai' | 'claude' | 'google';
+export type Action = 'create' | 'new' | 'edit' | 'update' | 'delete' | 'remove' | 'view';
+export type AIStatus = 'none' | 'suggesting' | 'thinking' | 'typing';
+export type ChatLevel = 'full' | 'basic' | 'none';
+export interface RouteConfig {
+    path: string;
+    title: string;
+    description: string;
+}
+export interface ServerConfig {
+    domain?: string;
+    port?: number;
+    suffix?: string;
+    secure?: boolean;
+    schema?: any;
+    additionalContext?: string;
+    stayOnPage?: boolean;
+}
+export interface TrainingDataPaths {
+    components: string[];
+    schemas: string[];
+    constants: string[];
+    types: string[];
+    api: string[];
+    utils: string[];
+    training: string[];
+}
+export interface TrainingCustomData {
+    instructions?: string;
+    domain?: Record<string, any>;
+    options?: Record<string, any>;
+    businessRules?: Record<string, any>;
+}
+export interface TrainingConfig {
+    filePaths: TrainingDataPaths;
+    routes?: RouteConfig[];
+    customTrainingData?: TrainingCustomData;
+    verboseLogging?: boolean;
+}
+export interface ProcessedTrainingData {
+    components: Array<{
+        filePath: string;
+        content: {
+            componentName: string;
+            props: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+            }>;
+            formFields: string[];
+        };
+    }>;
+    schemas: Array<{
+        filePath: string;
+        content: {
+            modelName: string;
+            fields: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                dataType: string;
+            }>;
+        };
+    }>;
+    constants: Array<{
+        filePath: string;
+        content: {
+            constValues: Array<{
+                name: string;
+                value: any;
+            }>;
+        };
+    }>;
+    types: Array<{
+        filePath: string;
+        content: {
+            typeName: string;
+            properties: Array<{
+                name: string;
+                type: string;
+                optional: boolean;
+            }>;
+        };
+    }>;
+    routes: RouteConfig[];
+    customTrainingData?: TrainingCustomData;
+}
+export interface TrainingData {
+    filePaths?: TrainingDataPaths;
+    verboseLogging?: boolean;
+    components?: Array<{
+        filePath: string;
+        content: {
+            componentName: string;
+            props: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+            }>;
+            formFields: string[];
+        };
+    }>;
+    schemas?: Array<{
+        filePath: string;
+        content: {
+            modelName: string;
+            fields: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                dataType: string;
+            }>;
+        };
+    }>;
+    constants?: Array<{
+        filePath: string;
+        content: {
+            constValues: Array<{
+                name: string;
+                value: any;
+            }>;
+        };
+    }>;
+    types?: Array<{
+        filePath: string;
+        content: {
+            typeName: string;
+            properties: Array<{
+                name: string;
+                type: string;
+                optional: boolean;
+            }>;
+        };
+    }>;
+    routes?: RouteConfig[];
+    customTrainingData?: TrainingCustomData;
+}
+export interface AIServiceConfig {
+    providers?: Record<string, {
+        apiKey: string;
+        models: string[];
+    }>;
+    openaiApiKey?: string;
+    claudeApiKey?: string;
+    geminiApiKey?: string;
+    chatLevel?: 'full' | 'basic' | 'none';
+    verboseLogging?: boolean;
+    trainingData?: ProcessedTrainingData;
+    trainingConfig?: TrainingConfig;
+    model?: string | null;
+    maxTokens?: number;
+    temperature?: number;
+    writeConfigToFile?: boolean;
+    baseDir?: string;
+}
+export interface CommandConfig extends AIServiceConfig {
+    service?: AIProvider | null;
+    apiKey?: string | null;
+}
+export interface TextContent {
+    type: 'text';
+    content: string;
+}
+export interface SuggestionsContent {
+    type: 'suggestions';
+    content: CommandSuggestion[];
+}
+export interface LoadingSuggestionsContent {
+    type: 'loading-suggestions';
+    content: string;
+}
+export type MessageContent = TextContent | SuggestionsContent | LoadingSuggestionsContent;
+export interface ChatMessage {
+    sender: 'user' | 'ai' | 'system';
+    content: MessageContent[];
+    action?: string;
+    isLoading?: boolean;
+    aiStatus?: AIStatus;
+    isError?: boolean;
+    errorType?: string;
+    retryAfter?: number;
+    timestamp?: number;
+    files?: File[];
+    suggestions?: CommandSuggestion[];
+}
+export interface ModelCapabilities {
+    supportsImages: boolean;
+    supportsAudio?: boolean;
+    supportsVideo?: boolean;
+    maxTokens?: number;
+    contextWindow?: number;
+    computeWeight?: number;
+}
+export interface CurrentModel {
+    model: string;
+    provider: string;
+}
+export interface ModelInfo {
+    id: string;
+    name: string;
+    provider: string;
+    available: boolean;
+    error?: string;
+    supportsImages: boolean;
+    computeWeight: number;
+    description?: string;
+}
+export interface ProviderStats {
+    name: string;
+    requests: number;
+}
+export 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;
+}
+export interface Store {
+    ai: {
+        form: Record<string, unknown>;
+        setForm: (state: Record<string, unknown>) => void;
+    };
+}
+export interface ModelSwitcherData {
+    modelsByProvider: Record<string, ModelInfo[]>;
+    currentModel: CurrentModel | null;
+    currentCapabilities: ModelCapabilities | null;
+    usageStats: UsageStats | null;
+    isLoading: boolean;
+    error: string | null;
+    switchModel: (modelId: string, provider: string) => Promise<void>;
+    integrationMode: string;
+}
+export interface ServerOptions extends AIServiceConfig {
+    port?: number;
+    baseDir?: string;
+    service?: AIProvider;
+    apiKey?: string;
+    customTrainingData?: Partial<TrainingCustomData>;
+}
+export interface CommandServer {
+    app: any;
+    start: () => void;
+    stop: () => void;
+    getConfig: () => CommandConfig;
+}
+export interface ApiKeys {
+    openai?: string;
+    claude?: string;
+    gemini?: string;
+    [key: string]: string | undefined;
+}
+export interface DefaultModels {
+    openai: string[];
+    claude: string[];
+    gemini: string[];
+    [key: string]: string[];
+}
+export interface ImageContent {
+    type: string;
+    source?: {
+        type: string;
+        media_type: string;
+        data: string;
+    };
+    image_url?: {
+        url: string;
+    };
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+}
+export interface Provider {
+    apiKey: string;
+    models?: string[];
+}
+export type Intent = 'CORRECTION' | 'COMPLETION' | 'DATA_ENTRY' | 'NAVIGATION' | 'INFORMATION';
+export interface AnalysisContext {
+    entities: Map<string, any>;
+    formStates: Map<string, any>;
+    userPreferences: Map<string, any>;
+    recentActions: string[];
+    intent: Intent;
+    extractedData: Record<string, any>;
+}
+export interface DataType {
+    pattern: RegExp;
+    convert: (value: string) => any;
+}
+/**
+ * JSON Schema definition for data that the AI should generate
+ * This follows JSON Schema specification but simplified for common use cases
+ */
+export interface SchemaDefinition {
+    title?: string;
+    description?: string;
+    type: 'object' | 'array' | 'string' | 'number' | 'boolean';
+    properties?: Record<string, SchemaProperty>;
+    required?: string[];
+    items?: SchemaProperty;
+}
+/**
+ * Individual property definition in a schema
+ */
+export interface SchemaProperty {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    enum?: string[] | number[];
+    items?: SchemaProperty;
+    properties?: Record<string, SchemaProperty>;
+    required?: string[];
+    default?: any;
+    format?: string;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+}
+/**
+ * Simplified config for ContextualCommandService
+ */
+export interface ContextualServiceConfig {
+    openaiApiKey?: string;
+    claudeApiKey?: string;
+    geminiApiKey?: string;
+    providers?: Record<string, {
+        apiKey: string;
+        models: string[];
+    }>;
+    chatLevel?: 'full' | 'basic' | 'none';
+    temperature?: number;
+    maxTokens?: number;
+    verboseLogging?: boolean;
+}
+/**
+ * Request structure for contextual service
+ */
+export interface ContextualRequest {
+    command: string;
+    schema?: SchemaDefinition;
+    chatHistory?: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>;
+    modelSelection?: {
+        provider: string;
+        model: string;
+    };
+    chatLevel?: 'full' | 'basic' | 'none';
+    additionalContext?: string;
+    images?: any[];
+}