@vfarcic/dot-ai/dist/core/schema.d.ts

AI-powered development productivity platform that enhances software development workflows through intelligent automation and AI-driven assistance

/**
 * Resource Schema Parser and Validator
 *
 * Implements comprehensive schema parsing and validation for Kubernetes resources
 * Fetches structured OpenAPI schemas from Kubernetes API server and validates manifests
 */
import { ResourceExplanation } from './discovery';
import { AIProvider } from './ai-provider.interface';
import { HelmChartInfo } from './helm-types';
export interface FieldConstraints {
    minimum?: number;
    maximum?: number;
    minLength?: number;
    maxLength?: number;
    enum?: string[];
    default?: unknown;
    pattern?: string;
}
export interface SchemaField {
    name: string;
    type: string;
    description: string;
    required: boolean;
    default?: unknown;
    constraints?: FieldConstraints;
    nested: Map<string, SchemaField>;
}
export interface ResourceSchema {
    apiVersion: string;
    kind: string;
    group: string;
    version?: string;
    description: string;
    properties: Map<string, SchemaField>;
    required?: string[];
    namespace?: boolean;
    resourceName?: string;
    rawExplanation?: string;
}
export interface ValidationResult {
    valid: boolean;
    errors: string[];
    warnings: string[];
}
export interface ResourceMapping {
    resourceKind: string;
    apiVersion: string;
    group?: string;
    fieldPath: string;
}
export interface AnswerSet {
    [questionId: string]: unknown;
}
export interface EnhancedSolution extends ResourceSolution {
    answers: AnswerSet;
    openAnswer: string;
}
export interface Question {
    id: string;
    question: string;
    type: 'text' | 'select' | 'multiselect' | 'boolean' | 'number';
    options?: string[];
    placeholder?: string;
    validation?: {
        required?: boolean;
        min?: number;
        max?: number;
        pattern?: string;
        message?: string;
    };
    suggestedAnswer?: unknown;
    answer?: unknown;
}
export interface QuestionGroup {
    required: Question[];
    basic: Question[];
    advanced: Question[];
    open: {
        question: string;
        placeholder: string;
        answer?: string;
    };
    relevantPolicies?: string[];
}
/**
 * Packaging questions for capability-based solutions (not Helm charts)
 * These are injected programmatically after AI generates questions
 */
export declare const OUTPUT_FORMAT_QUESTION: Question;
export declare const OUTPUT_PATH_QUESTION: Question;
export interface ResourceSolution {
    type: 'single' | 'combination';
    resources: ResourceSchema[];
    score: number;
    description: string;
    reasons: string[];
    questions: QuestionGroup;
    appliedPatterns?: string[];
}
export interface HelmRecommendation {
    reason: string;
    suggestedTool: string;
    searchQuery: string;
}
export interface SolutionResult {
    solutions: ResourceSolution[];
    helmRecommendation: HelmRecommendation | null;
}
export interface ClusterResourceInfo {
    name: string;
    isDefault: boolean;
}
export interface ClusterOptions {
    namespaces: string[];
    storageClasses: ClusterResourceInfo[];
    ingressClasses: ClusterResourceInfo[];
    nodeLabels: string[];
    serviceAccounts?: {
        [namespace: string]: string[];
    };
}
/**
 * SchemaParser converts kubectl explain output to structured ResourceSchema
 */
export declare class SchemaParser {
    /**
     * Parse ResourceExplanation from discovery engine into structured schema
     */
    parseResourceExplanation(explanation: ResourceExplanation): ResourceSchema;
    /**
     * Add nested field to the schema structure
     */
    private addNestedField;
    /**
     * Normalize field types from kubectl explain output
     */
    private normalizeType;
    /**
     * Parse field constraints from description text
     */
    parseFieldConstraints(type: string, description: string): FieldConstraints;
}
/**
 * ManifestValidator validates Kubernetes manifests using kubectl dry-run
 * PRD #343: Supports plugin system for kubectl operations
 */
export declare class ManifestValidator {
    /**
     * PRD #359: Uses unified plugin registry for kubectl operations
     */
    constructor();
    /**
     * Execute kubectl via plugin system
     * PRD #359: ALL Kubernetes operations go through unified plugin registry
     */
    private executeKubectlViaPlugin;
    /**
     * Validate a manifest using kubectl dry-run
     * This uses the actual Kubernetes API server validation for accuracy
     * PRD #359: Routes through unified plugin registry
     */
    validateManifest(manifestPath: string, config?: {
        dryRunMode?: 'client' | 'server';
    }): Promise<ValidationResult>;
    /**
     * Add best practice warnings
     */
    private addBestPracticeWarnings;
}
/**
 * ResourceRecommender determines which resources best meet user needs using AI
 * PRD #359: Uses unified plugin registry for kubectl operations
 */
export declare class ResourceRecommender {
    private aiProvider;
    private patternService?;
    private capabilityService?;
    private policyService?;
    constructor(aiProvider?: AIProvider);
    /**
     * Execute kubectl via plugin system
     * PRD #359: ALL Kubernetes operations go through unified plugin registry
     */
    private executeKubectlViaPlugin;
    /**
     * Find the best resource solution(s) for user intent using two-phase analysis
     */
    findBestSolutions(intent: string, _explainResource: (resource: string) => Promise<string>, interaction_id?: string): Promise<SolutionResult>;
    /**
     * Phase 2: AI assembles and ranks complete solutions (replaces separate selection + ranking)
     */
    private assembleAndRankSolutions;
    /**
     * Parse AI response for simple solution structure (no schema matching needed)
     */
    private parseSimpleSolutionResponse;
    /**
     * Load and format solution assembly prompt from file
     */
    private loadSolutionAssemblyPrompt;
    /**
     * Add pattern-suggested resources that are missing from capability search results
     */
    private addMissingPatternResources;
    /**
     * Infer cloud providers from resource name
     */
    private inferProvidersFromResourceName;
    /**
     * Extract Kubernetes kind from resource name (e.g., "sqls.devopstoolkit.live" -> "SQL")
     */
    private extractKindFromResourceName;
    /**
     * Extract group from resource name (e.g., "sqls.devopstoolkit.live" -> "devopstoolkit.live")
     */
    private extractGroupFromResourceName;
    /**
     * Phase 0: Search for relevant organizational patterns using multi-concept approach
     * Returns empty array if Vector DB is not available - this is completely optional
     */
    private searchRelevantPatterns;
    /**
     * Phase 2: Fetch detailed schemas for selected candidates
     */
    private fetchDetailedSchemas;
    /**
     * Discover cluster options for dynamic question generation
     * PRD #343: ALL kubectl operations go through plugin
     */
    private discoverClusterOptions;
    /**
     * Format cluster options for inclusion in prompts
     */
    private formatClusterOptionsText;
    /**
     * Generate contextual questions using AI based on user intent and solution resources
     */
    private generateQuestionsWithAI;
    /**
     * Generate contextual questions for Helm chart installation
     */
    generateQuestionsForHelmChart(intent: string, chart: HelmChartInfo, description: string, interaction_id?: string): Promise<QuestionGroup>;
    /**
     * Fetch Helm chart values.yaml and README
     */
    fetchHelmChartContent(chart: HelmChartInfo): Promise<{
        valuesYaml: string;
        readme: string;
    }>;
}
//# sourceMappingURL=schema.d.ts.map