claritykit-svelte
Version:
A comprehensive Svelte component library focused on accessibility, ADHD-optimized design, developer experience, and full SSR compatibility
529 lines • 14.6 kB
TypeScript
import type { HTMLAttributes } from 'svelte/elements';
export type TemplateCategory = 'universal' | 'rest' | 'graphql' | 'webhook' | 'custom';
export type OutputFormat = 'python' | 'javascript' | 'typescript' | 'go' | 'rust';
export type GenerationStatus = 'pending' | 'generating' | 'completed' | 'failed';
export type GenerationStage = 'idle' | 'preparing' | 'generating' | 'validating' | 'complete';
export interface TemplateVariable {
name: string;
type: 'string' | 'number' | 'boolean' | 'array' | 'object';
description: string;
required: boolean;
defaultValue?: any;
validation?: {
pattern?: string;
min?: number;
max?: number;
options?: string[];
};
}
export interface MetapTemplate {
id: string;
name: string;
description: string;
category: TemplateCategory;
content: string;
variables: TemplateVariable[];
instructions: string;
outputFormat: OutputFormat;
version: number;
createdAt: Date;
updatedAt: Date;
usage: {
count: number;
lastUsed: Date;
averageExecutionTime?: number;
successRate?: number;
};
config?: {
modelPreferences?: string[];
temperatureRange?: {
min: number;
max: number;
};
maxTokens?: number;
timeout?: number;
};
testCases?: Array<{
name: string;
context: Record<string, any>;
expectedPatterns: string[];
}>;
}
export interface TemplateContext {
[key: string]: any;
service_name?: string;
class_name?: string;
base_url?: string;
endpoints?: Array<{
path: string;
method: string;
operation_id: string;
description?: string;
parameters: Array<{
name: string;
type: string;
required: boolean;
location: 'path' | 'query' | 'header' | 'body';
}>;
}>;
schemas?: Record<string, any>;
auth_methods?: Array<{
type: string;
name: string;
location?: string;
}>;
bms_integrations?: {
oracle_access: boolean;
scribe_access: boolean;
architect_access: boolean;
loop_diagnostics: boolean;
};
generation_config?: {
include_tests: boolean;
include_documentation: boolean;
error_handling: 'basic' | 'comprehensive';
logging_level: 'minimal' | 'detailed';
};
}
export interface GenerationRequest {
id: string;
templateId: string;
context: TemplateContext;
model: string;
temperature: number;
maxTokens: number;
customInstructions?: string;
status: GenerationStatus;
startedAt: Date;
completedAt?: Date;
error?: string;
retryCount?: number;
}
export interface GenerationResult {
requestId: string;
generatedCode: string;
metadata: {
tokensUsed: number;
executionTime: number;
model: string;
templateVersion: number;
generatedAt: Date;
};
validation: {
syntaxValid: boolean;
semanticValid: boolean;
warnings: string[];
suggestions: string[];
complexity?: {
cyclomaticComplexity: number;
maintainabilityIndex: number;
linesOfCode: number;
};
};
artifacts?: {
mainFile: string;
testFile?: string;
documentation?: string;
configFile?: string;
requirements?: string[];
};
}
export interface GenerationProgress {
stage: GenerationStage;
progress: number;
message: string;
estimatedTime: number;
currentStep?: string;
totalSteps?: number;
}
export interface TemplateEngineProps extends HTMLAttributes<HTMLDivElement> {
/**
* Available templates
*/
templates?: MetapTemplate[];
/**
* Generation history
*/
generationHistory?: GenerationRequest[];
/**
* Available AI models
*/
availableModels?: string[];
/**
* Default template to select
*/
defaultTemplate?: MetapTemplate;
/**
* Show template editor interface
* @default true
*/
showTemplateEditor?: boolean;
/**
* Show generation logs
* @default true
*/
showGenerationLogs?: boolean;
/**
* Enable custom template creation
* @default true
*/
enableCustomTemplates?: boolean;
/**
* Default generation configuration
*/
generationConfig?: {
model: string;
temperature: number;
maxTokens: number;
timeout: number;
};
/**
* Callback when template is created
*/
onTemplateCreate?: (template: MetapTemplate) => void;
/**
* Callback when generation starts
*/
onGenerationStart?: (request: GenerationRequest) => void;
/**
* Callback when generation completes
*/
onGenerationComplete?: (request: GenerationRequest, result: GenerationResult) => void;
/**
* Callback when template is updated
*/
onTemplateUpdate?: (template: MetapTemplate) => void;
/**
* Callback when template is deleted
*/
onTemplateDelete?: (templateId: string) => void;
/**
* Callback when validation fails
*/
onValidationError?: (errors: string[]) => void;
}
export interface MetapEngine {
/**
* Generate code using a template and context
*/
generate: (template: MetapTemplate, context: TemplateContext, config?: GenerationConfig) => Promise<GenerationResult>;
/**
* Validate template syntax and structure
*/
validateTemplate: (template: MetapTemplate) => Promise<TemplateValidationResult>;
/**
* Test template with provided test cases
*/
testTemplate: (template: MetapTemplate, testCases: TemplateTestCase[]) => Promise<TemplateTestResult[]>;
/**
* Optimize template for better performance
*/
optimizeTemplate: (template: MetapTemplate) => Promise<MetapTemplate>;
/**
* Get available models and their capabilities
*/
getAvailableModels: () => Promise<ModelInfo[]>;
}
export interface GenerationConfig {
model: string;
temperature: number;
maxTokens: number;
timeout: number;
stopSequences?: string[];
streaming?: boolean;
presencePenalty?: number;
frequencyPenalty?: number;
topP?: number;
topK?: number;
format?: 'text' | 'json' | 'yaml';
prettify?: boolean;
includeComments?: boolean;
contentFilter?: boolean;
safetyLevel?: 'low' | 'medium' | 'high';
}
export interface TemplateValidationResult {
valid: boolean;
errors: Array<{
type: 'syntax' | 'semantic' | 'variable' | 'instruction';
message: string;
line?: number;
column?: number;
severity: 'error' | 'warning' | 'info';
}>;
warnings: string[];
suggestions: string[];
score: number;
}
export interface TemplateTestCase {
name: string;
description?: string;
context: TemplateContext;
expectedPatterns: string[];
expectedNotPatterns?: string[];
expectedMetrics?: {
minTokens?: number;
maxTokens?: number;
minComplexity?: number;
maxComplexity?: number;
};
}
export interface TemplateTestResult {
testCase: string;
passed: boolean;
generatedCode: string;
matchedPatterns: string[];
failedPatterns: string[];
metrics: {
tokens: number;
complexity: number;
executionTime: number;
};
issues: string[];
}
export interface ModelInfo {
id: string;
name: string;
provider: string;
capabilities: {
maxTokens: number;
supportedFormats: string[];
streaming: boolean;
codeGeneration: boolean;
languageSupport: string[];
};
pricing?: {
inputCostPer1K: number;
outputCostPer1K: number;
currency: string;
};
limitations?: string[];
}
export interface UniversalIntegrationTemplate extends MetapTemplate {
category: 'universal';
variables: [
{
name: 'service_name';
type: 'string';
required: true;
},
{
name: 'class_name';
type: 'string';
required: true;
},
{
name: 'base_url';
type: 'string';
required: true;
},
{
name: 'endpoints';
type: 'array';
required: true;
},
{
name: 'auth_methods';
type: 'array';
required: true;
},
...TemplateVariable[]
];
}
export interface RESTAPITemplate extends MetapTemplate {
category: 'rest';
restConfig: {
authTypes: ('apiKey' | 'oauth2' | 'bearer' | 'basic')[];
dataFormats: ('json' | 'xml' | 'form')[];
supportedMethods: ('GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH')[];
paginationSupport: boolean;
rateLimitingSupport: boolean;
};
}
export interface GraphQLTemplate extends MetapTemplate {
category: 'graphql';
graphqlConfig: {
schemaIntrospection: boolean;
subscriptionSupport: boolean;
fragmentSupport: boolean;
variableSupport: boolean;
directiveSupport: boolean;
};
}
export interface WebhookTemplate extends MetapTemplate {
category: 'webhook';
webhookConfig: {
httpMethods: string[];
signatureValidation: boolean;
retryLogic: boolean;
payloadTransformation: boolean;
eventFiltering: boolean;
};
}
export interface TemplateLibrary {
/**
* Get all templates
*/
getTemplates: (category?: TemplateCategory) => Promise<MetapTemplate[]>;
/**
* Create new template
*/
createTemplate: (template: Omit<MetapTemplate, 'id' | 'createdAt' | 'updatedAt'>) => Promise<MetapTemplate>;
/**
* Update existing template
*/
updateTemplate: (id: string, updates: Partial<MetapTemplate>) => Promise<MetapTemplate>;
/**
* Delete template
*/
deleteTemplate: (id: string) => Promise<void>;
/**
* Clone template
*/
cloneTemplate: (id: string, newName: string) => Promise<MetapTemplate>;
/**
* Import template from file
*/
importTemplate: (templateData: string) => Promise<MetapTemplate>;
/**
* Export template to file
*/
exportTemplate: (id: string) => Promise<string>;
/**
* Search templates
*/
searchTemplates: (query: string) => Promise<MetapTemplate[]>;
/**
* Get template usage statistics
*/
getUsageStats: (id: string) => Promise<TemplateUsageStats>;
}
export interface TemplateUsageStats {
templateId: string;
totalGenerations: number;
successfulGenerations: number;
failedGenerations: number;
averageExecutionTime: number;
mostCommonContext: Record<string, any>;
errorPatterns: Array<{
error: string;
frequency: number;
lastOccurred: Date;
}>;
performanceMetrics: {
avgTokensGenerated: number;
avgComplexity: number;
userSatisfactionScore?: number;
};
}
export interface BMSTemplateIntegration {
/**
* Generate agent template for Oracle integrations
*/
generateOracleAgentTemplate: (serviceName: string, capabilities: string[]) => Promise<MetapTemplate>;
/**
* Generate agent template for Scribe data access
*/
generateScribeAgentTemplate: (serviceName: string, dataTypes: string[]) => Promise<MetapTemplate>;
/**
* Generate agent template for Architect workflows
*/
generateArchitectAgentTemplate: (services: string[], workflowType: string) => Promise<MetapTemplate>;
/**
* Get BMS-optimized generation context
*/
getBMSContext: (integrationRequest: any) => Promise<TemplateContext>;
/**
* Validate BMS compatibility
*/
validateBMSCompatibility: (template: MetapTemplate) => Promise<{
compatible: boolean;
requiredModifications: string[];
compatibilityScore: number;
}>;
}
export interface CodeQualityAnalyzer {
/**
* Analyze generated code quality
*/
analyzeQuality: (code: string, language: string) => Promise<CodeQualityReport>;
/**
* Suggest optimizations
*/
suggestOptimizations: (code: string, language: string) => Promise<OptimizationSuggestion[]>;
/**
* Check security vulnerabilities
*/
checkSecurity: (code: string, language: string) => Promise<SecurityReport>;
/**
* Estimate performance metrics
*/
estimatePerformance: (code: string, language: string) => Promise<PerformanceEstimate>;
}
export interface CodeQualityReport {
overallScore: number;
metrics: {
cyclomaticComplexity: number;
maintainabilityIndex: number;
technicalDebt: number;
testCoverage?: number;
documentation: number;
};
issues: Array<{
type: 'bug' | 'vulnerability' | 'code_smell' | 'duplication';
severity: 'info' | 'minor' | 'major' | 'critical' | 'blocker';
message: string;
line?: number;
suggestion?: string;
}>;
recommendations: string[];
}
export interface OptimizationSuggestion {
type: 'performance' | 'readability' | 'maintainability' | 'security';
priority: 'low' | 'medium' | 'high';
description: string;
originalCode: string;
optimizedCode: string;
expectedBenefit: string;
effort: 'minimal' | 'moderate' | 'significant';
}
export interface SecurityReport {
riskLevel: 'low' | 'medium' | 'high' | 'critical';
vulnerabilities: Array<{
type: string;
severity: string;
description: string;
location: {
line: number;
column?: number;
};
recommendation: string;
cwe?: string;
}>;
securityScore: number;
compliance: {
owasp: boolean;
gdpr?: boolean;
hipaa?: boolean;
};
}
export interface PerformanceEstimate {
executionTime: {
best: number;
average: number;
worst: number;
unit: 'ms' | 's' | 'm';
};
memoryUsage: {
estimated: number;
peak: number;
unit: 'KB' | 'MB' | 'GB';
};
resourceIntensity: 'low' | 'medium' | 'high';
scalabilityScore: number;
bottlenecks: Array<{
location: string;
description: string;
impact: 'low' | 'medium' | 'high';
}>;
}
//# sourceMappingURL=types.d.ts.map