@task-shepherd/agent 1.0.5 → 1.0.7

package/shared/dist/workspace/validation.js

@@ -0,0 +1,467 @@
+/**
+ * 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 }));
+    }
+}