@task-shepherd/agent 1.0.7 → 1.0.11

package/shared/dist/workspace/validation.js

@@ -1,467 +0,0 @@
-/**
- * Zod Validation Schemas for Workspace Configuration
- *
- * Provides runtime type safety and validation for all workspace configuration types.
- */
-import { z } from 'zod';
-/**
- * Base validation schemas
- */
-export const WorkspacePatternSchema = z.enum(['monorepo', 'multi-repo', 'hybrid']);
-export const ServiceTechnologySchema = z.enum([
-    'nodejs', 'python', 'go', 'rust', 'java', 'dotnet', 'php', 'ruby',
-    'react', 'vue', 'angular', 'static', 'database', 'cache', 'queue', 'other'
-]);
-export const EnvironmentSchema = z.enum(['development', 'staging', 'production', 'test']);
-export const ProtocolSchema = z.enum([
-    'http', 'https', 'ws', 'wss', 'tcp', 'udp', 'grpc',
-    'postgresql', 'redis', 'mongodb'
-]);
-export const AuthTypeSchema = z.enum([
-    'none', 'basic', 'bearer', 'apikey', 'oauth2', 'custom'
-]);
-export const PackageManagerSchema = z.enum([
-    'npm', 'yarn', 'pnpm', 'pip', 'go mod', 'cargo', 'maven', 'gradle'
-]);
-export const AIProviderSchema = z.enum([
-    'claude', 'openai', 'gemini', 'azure', 'custom'
-]);
-export const IsolationLevelSchema = z.enum(['strict', 'moderate', 'relaxed']);
-export const SeverityLevelSchema = z.enum(['error', 'warning', 'info']);
-/**
- * Service dependency validation schema
- */
-export const ServiceDependencySchema = z.object({
-    service: z.string().min(1, 'Service name is required'),
-    type: z.enum(['required', 'optional', 'development']),
-    version: z.string().optional(),
-    description: z.string().optional()
-});
-/**
- * Service authentication validation schema
- */
-export const ServiceAuthenticationSchema = z.object({
-    type: AuthTypeSchema,
-    credentials: z.record(z.string(), z.string()).optional(),
-    headers: z.record(z.string(), z.string()).optional()
-});
-/**
- * Service endpoint validation schema
- */
-export const ServiceEndpointSchema = z.object({
-    id: z.string().min(1, 'Service ID is required'),
-    name: z.string().min(1, 'Service name is required'),
-    description: z.string().optional(),
-    url: z.string().url('Invalid service URL'),
-    port: z.number().int().min(1).max(65535, 'Port must be between 1 and 65535'),
-    protocol: ProtocolSchema,
-    technology: ServiceTechnologySchema,
-    environment: EnvironmentSchema,
-    healthCheck: z.string().optional(),
-    version: z.string().optional(),
-    dependencies: z.array(ServiceDependencySchema).default([]),
-    auth: ServiceAuthenticationSchema.optional(),
-    metadata: z.record(z.string(), z.any()).optional()
-});
-/**
- * Repository configuration validation schema
- */
-export const RepositoryConfigSchema = z.object({
-    id: z.string().min(1, 'Repository ID is required'),
-    name: z.string().min(1, 'Repository name is required'),
-    url: z.string().url('Invalid repository URL'),
-    path: z.string().min(1, 'Repository path is required'),
-    branch: z.string().min(1, 'Default branch is required').default('main'),
-    type: z.enum(['primary', 'service', 'library', 'config']),
-    services: z.array(z.string()).default([]),
-    config: z.object({
-        packageManager: PackageManagerSchema.optional(),
-        buildCommands: z.array(z.string()).optional(),
-        testCommands: z.array(z.string()).optional(),
-        lintCommands: z.array(z.string()).optional()
-    }).optional()
-});
-/**
- * AI model configuration validation schema
- */
-export const AIModelConfigSchema = z.object({
-    provider: AIProviderSchema,
-    model: z.string().min(1, 'Model name is required'),
-    apiKey: z.string().min(1, 'API key is required'),
-    config: z.record(z.string(), z.any()).optional(),
-    rateLimit: z.object({
-        requestsPerMinute: z.number().int().positive().optional(),
-        tokensPerMinute: z.number().int().positive().optional(),
-        requestsPerDay: z.number().int().positive().optional()
-    }).optional()
-});
-/**
- * AI capabilities validation schema
- */
-export const AICapabilitiesSchema = z.object({
-    maxConcurrentOperations: z.number().int().positive().default(3),
-    supportedAnalysisTypes: z.array(z.string()).min(1, 'At least one analysis type is required'),
-    isolationLevel: IsolationLevelSchema.default('moderate'),
-    serviceCapabilities: z.record(z.string(), z.array(z.string())).optional(),
-    customCapabilities: z.record(z.string(), z.any()).optional()
-});
-/**
- * Workspace paths validation schema
- */
-export const WorkspacePathsSchema = z.object({
-    root: z.string().min(1, 'Root path is required').default('.'),
-    src: z.array(z.string()).default(['src']),
-    tests: z.array(z.string()).default(['test', 'tests']),
-    docs: z.array(z.string()).default(['docs']),
-    config: z.array(z.string()).default(['config']),
-    build: z.array(z.string()).default(['build', 'dist']),
-    temp: z.array(z.string()).default(['tmp', 'temp']),
-    logs: z.array(z.string()).default(['logs']),
-    cache: z.array(z.string()).default(['cache', '.cache']),
-    assets: z.array(z.string()).default(['assets', 'public']),
-    excluded: z.array(z.string()).default(['node_modules', '.git', '.env']),
-    servicePaths: z.record(z.string(), z.array(z.string())).optional()
-});
-/**
- * Security configuration validation schema
- */
-export const SecurityConfigSchema = z.object({
-    filePermissions: z.object({
-        read: z.boolean().default(true),
-        write: z.boolean().default(true),
-        execute: z.boolean().default(false),
-        restricted: z.array(z.string()).default(['.env', '.env.local', '.env.production']),
-        readOnly: z.array(z.string()).default([])
-    }),
-    networkPermissions: z.object({
-        http: z.boolean().default(true),
-        https: z.boolean().default(true),
-        allowedDomains: z.array(z.string()).default(['api.anthropic.com', 'api.openai.com']),
-        blockedDomains: z.array(z.string()).default([]),
-        allowedPorts: z.array(z.number().int().min(1).max(65535)).optional()
-    }),
-    apiAccess: z.object({
-        allowedEndpoints: z.array(z.string()),
-        rateLimits: z.record(z.string(), z.number().positive()).optional()
-    }).optional()
-});
-/**
- * Development configuration validation schema
- */
-export const DevelopmentConfigSchema = z.object({
-    packageManager: PackageManagerSchema.default('npm'),
-    runtimeVersions: z.object({
-        node: z.string().optional(),
-        python: z.string().optional(),
-        go: z.string().optional(),
-        rust: z.string().optional(),
-        java: z.string().optional(),
-        dotnet: z.string().optional()
-    }).optional(),
-    env: z.record(z.string(), z.string()).optional(),
-    scripts: z.object({
-        start: z.string().optional(),
-        build: z.string().optional(),
-        test: z.string().optional(),
-        lint: z.string().optional(),
-        typeCheck: z.string().optional(),
-        dbSetup: z.string().optional(),
-        clean: z.string().optional()
-    }).optional(),
-    tools: z.object({
-        formatter: z.enum(['prettier', 'black', 'gofmt', 'rustfmt', 'custom']).optional(),
-        linter: z.enum(['eslint', 'pylint', 'golangci-lint', 'clippy', 'custom']).optional(),
-        testFramework: z.enum(['jest', 'vitest', 'pytest', 'go test', 'cargo test', 'custom']).optional()
-    }).optional()
-});
-/**
- * Integrations configuration validation schema
- */
-export const IntegrationsConfigSchema = z.object({
-    tasqhub: z.object({
-        apiUrl: z.string().url('Invalid TasqHub API URL'),
-        apiKey: z.string().min(1, 'TasqHub API key is required'),
-        projectId: z.string().optional(),
-        workspaceId: z.string().optional()
-    }).optional(),
-    git: z.object({
-        remotes: z.record(z.string(), z.string().url('Invalid repository URL')),
-        defaultBranch: z.string().default('main'),
-        hooks: z.object({
-            preCommit: z.array(z.string()).optional(),
-            postCommit: z.array(z.string()).optional(),
-            prePush: z.array(z.string()).optional(),
-            postMerge: z.array(z.string()).optional()
-        }).optional()
-    }).optional(),
-    cicd: z.object({
-        provider: z.enum(['github-actions', 'gitlab-ci', 'jenkins', 'azure-devops', 'custom']),
-        configPath: z.string().optional(),
-        pipelines: z.record(z.string(), z.any()).optional()
-    }).optional(),
-    containers: z.object({
-        runtime: z.enum(['docker', 'podman', 'containerd']),
-        registry: z.object({
-            url: z.string().url(),
-            credentials: z.record(z.string(), z.string()).optional()
-        }).optional(),
-        composeFiles: z.array(z.string()).optional()
-    }).optional(),
-    cloud: z.object({
-        provider: z.enum(['aws', 'gcp', 'azure', 'custom']),
-        config: z.record(z.string(), z.any()).optional()
-    }).optional()
-});
-/**
- * Workspace metadata validation schema
- */
-export const WorkspaceMetadataSchema = z.object({
-    id: z.string().uuid('Invalid workspace ID format'),
-    name: z.string().min(1, 'Workspace name is required').max(100, 'Workspace name too long'),
-    description: z.string().max(500, 'Description too long').optional(),
-    pattern: WorkspacePatternSchema,
-    version: z.string().regex(/^\d+\.\d+\.\d+$/, 'Invalid version format (use semver)'),
-    createdAt: z.string().datetime('Invalid creation timestamp'),
-    updatedAt: z.string().datetime('Invalid update timestamp'),
-    tags: z.array(z.string()).optional(),
-    owner: z.object({
-        name: z.string().min(1),
-        email: z.string().email('Invalid owner email')
-    }).optional(),
-    team: z.array(z.object({
-        name: z.string().min(1),
-        email: z.string().email('Invalid team member email'),
-        role: z.string().min(1)
-    })).optional()
-});
-/**
- * Complete workspace configuration validation schema
- */
-export const WorkspaceConfigSchema = z.object({
-    workspace: WorkspaceMetadataSchema,
-    services: z.record(z.string(), ServiceEndpointSchema).refine((services) => Object.keys(services).length > 0, 'At least one service must be defined'),
-    repositories: z.record(z.string(), RepositoryConfigSchema).optional(),
-    ai: z.object({
-        models: z.record(z.string(), AIModelConfigSchema).refine((models) => Object.keys(models).length > 0, 'At least one AI model must be configured'),
-        defaultModel: z.string().min(1, 'Default AI model is required'),
-        capabilities: AICapabilitiesSchema
-    }),
-    paths: WorkspacePathsSchema,
-    development: DevelopmentConfigSchema,
-    security: SecurityConfigSchema,
-    integrations: IntegrationsConfigSchema.optional(),
-    extensions: z.record(z.string(), z.any()).optional()
-}).refine((config) => {
-    // Validate that default AI model exists in models
-    return config.ai.defaultModel in config.ai.models;
-}, {
-    message: 'Default AI model must be defined in models configuration',
-    path: ['ai', 'defaultModel']
-}).refine((config) => {
-    // Validate service dependencies reference existing services
-    const serviceIds = Object.keys(config.services);
-    for (const [serviceId, service] of Object.entries(config.services)) {
-        for (const dep of service.dependencies) {
-            if (!serviceIds.includes(dep.service)) {
-                return false;
-            }
-        }
-    }
-    return true;
-}, {
-    message: 'Service dependencies must reference existing services',
-    path: ['services']
-});
-/**
- * Service discovery configuration validation schema
- */
-export const ServiceDiscoveryConfigSchema = z.object({
-    enabled: z.boolean().default(true),
-    methods: z.array(z.enum(['filesystem', 'docker-compose', 'kubernetes', 'consul', 'custom'])).min(1),
-    patterns: z.object({
-        files: z.array(z.string()).default(['package.json', 'Dockerfile', 'docker-compose.yml']),
-        directories: z.array(z.string()).default(['src', 'app', 'services']),
-        portRanges: z.array(z.object({
-            start: z.number().int().min(1).max(65535),
-            end: z.number().int().min(1).max(65535)
-        })).optional()
-    }),
-    overrides: z.record(z.string(), ServiceEndpointSchema).optional()
-});
-/**
- * Workspace validation configuration schema
- */
-export const WorkspaceValidationConfigSchema = z.object({
-    rules: z.object({
-        requiredServices: z.array(z.string()).optional(),
-        validateDependencies: z.boolean().default(true),
-        validatePaths: z.boolean().default(true),
-        detectPortConflicts: z.boolean().default(true),
-        customRules: z.array(z.object({
-            name: z.string().min(1),
-            description: z.string().min(1),
-            validator: z.string().min(1)
-        })).optional()
-    }),
-    severity: z.object({
-        missingServices: SeverityLevelSchema.default('error'),
-        circularDependencies: SeverityLevelSchema.default('error'),
-        portConflicts: SeverityLevelSchema.default('warning'),
-        invalidPaths: SeverityLevelSchema.default('warning')
-    })
-});
-/**
- * Workspace initialization options validation schema
- */
-export const WorkspaceInitOptionsSchema = z.object({
-    directory: z.string().optional(),
-    name: z.string().min(1).max(100).optional(),
-    description: z.string().max(500).optional(),
-    pattern: WorkspacePatternSchema.optional(),
-    template: z.string().optional(),
-    interactive: z.boolean().default(false),
-    force: z.boolean().default(false),
-    services: z.array(z.string()).optional(),
-    aiProvider: z.string().optional(),
-    repositories: z.array(z.string().url()).optional(),
-    discovery: ServiceDiscoveryConfigSchema.partial().optional()
-});
-/**
- * Workspace template validation schema
- */
-export const WorkspaceTemplateSchema = z.object({
-    id: z.string().min(1, 'Template ID is required'),
-    name: z.string().min(1, 'Template name is required'),
-    description: z.string().min(1, 'Template description is required'),
-    patterns: z.array(WorkspacePatternSchema).min(1, 'At least one pattern must be supported'),
-    config: WorkspaceConfigSchema.partial(),
-    requiredServices: z.array(z.string()).default([]),
-    optionalServices: z.array(z.string()).default([]),
-    setupSteps: z.array(z.string()).optional(),
-    variables: z.record(z.string(), z.object({
-        description: z.string().min(1),
-        type: z.enum(['string', 'number', 'boolean', 'array']),
-        default: z.any().optional(),
-        required: z.boolean().optional()
-    })).optional()
-});
-/**
- * Validation helper functions
- */
-export class WorkspaceValidator {
-    /**
-     * Validate workspace configuration
-     */
-    static validateWorkspaceConfig(config) {
-        const result = WorkspaceConfigSchema.safeParse(config);
-        if (result.success) {
-            return {
-                success: true,
-                data: result.data,
-                errors: []
-            };
-        }
-        return {
-            success: false,
-            errors: result.error.issues.map(err => ({
-                path: err.path.map(String),
-                message: err.message,
-                code: err.code
-            }))
-        };
-    }
-    /**
-     * Validate service endpoint configuration
-     */
-    static validateServiceEndpoint(endpoint) {
-        const result = ServiceEndpointSchema.safeParse(endpoint);
-        if (result.success) {
-            return {
-                success: true,
-                data: result.data,
-                errors: []
-            };
-        }
-        return {
-            success: false,
-            errors: result.error.issues.map(err => ({
-                path: err.path.map(String),
-                message: err.message,
-                code: err.code
-            }))
-        };
-    }
-    /**
-     * Validate workspace initialization options
-     */
-    static validateInitOptions(options) {
-        const result = WorkspaceInitOptionsSchema.safeParse(options);
-        if (result.success) {
-            return {
-                success: true,
-                data: result.data,
-                errors: []
-            };
-        }
-        return {
-            success: false,
-            errors: result.error.issues.map(err => ({
-                path: err.path.map(String),
-                message: err.message,
-                code: err.code
-            }))
-        };
-    }
-    /**
-     * Check for circular dependencies in services
-     */
-    static checkCircularDependencies(services) {
-        const visited = new Set();
-        const recursionStack = new Set();
-        const cycles = [];
-        const dfs = (serviceId, path = []) => {
-            if (recursionStack.has(serviceId)) {
-                const cycleStart = path.indexOf(serviceId);
-                const cycle = [...path.slice(cycleStart), serviceId];
-                cycles.push(cycle.join(' -> '));
-                return;
-            }
-            if (visited.has(serviceId)) {
-                return;
-            }
-            visited.add(serviceId);
-            recursionStack.add(serviceId);
-            const service = services[serviceId];
-            if (service?.dependencies) {
-                for (const dep of service.dependencies) {
-                    if (dep.type === 'required') {
-                        dfs(dep.service, [...path, serviceId]);
-                    }
-                }
-            }
-            recursionStack.delete(serviceId);
-        };
-        for (const serviceId of Object.keys(services)) {
-            if (!visited.has(serviceId)) {
-                dfs(serviceId);
-            }
-        }
-        return cycles;
-    }
-    /**
-     * Check for port conflicts
-     */
-    static checkPortConflicts(services) {
-        const portMap = new Map();
-        for (const [serviceId, service] of Object.entries(services)) {
-            const port = service.port;
-            if (!portMap.has(port)) {
-                portMap.set(port, []);
-            }
-            portMap.get(port).push(serviceId);
-        }
-        return Array.from(portMap.entries())
-            .filter(([_, serviceIds]) => serviceIds.length > 1)
-            .map(([port, serviceIds]) => ({ port, services: serviceIds }));
-    }
-}