@task-shepherd/agent 1.0.6 → 1.0.8

package/shared/dist/workspace/utils.js

@@ -0,0 +1,334 @@
+/**
+ * Workspace Configuration Utilities
+ *
+ * Helper functions for working with workspace configurations.
+ */
+import { WORKSPACE_TEMPLATES, COMMON_SERVICE_PORTS } from './constants.js';
+/**
+ * Create a workspace configuration from a template
+ */
+export function createWorkspaceFromTemplate(templateId, options) {
+    const template = WORKSPACE_TEMPLATES[templateId];
+    if (!template) {
+        throw new Error(`Template '${templateId}' not found`);
+    }
+    const config = {
+        ...template.config,
+        workspace: {
+            ...template.config.workspace,
+            id: generateWorkspaceId(),
+            name: options.name,
+            description: options.description,
+            pattern: options.pattern || template.config.workspace?.pattern || 'monorepo',
+            version: template.config.workspace?.version || '1.0.0',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        }
+    };
+    // Merge custom configuration
+    if (options.customConfig) {
+        return mergeWorkspaceConfigs(config, options.customConfig);
+    }
+    return config;
+}
+/**
+ * Merge workspace configurations
+ */
+export function mergeWorkspaceConfigs(base, override) {
+    return {
+        ...base,
+        ...override,
+        workspace: {
+            ...base.workspace,
+            ...override.workspace
+        },
+        services: {
+            ...base.services,
+            ...override.services
+        },
+        ai: base.ai && override.ai ? {
+            ...base.ai,
+            ...override.ai,
+            models: {
+                ...base.ai?.models,
+                ...override.ai?.models
+            },
+            capabilities: {
+                ...base.ai?.capabilities,
+                ...override.ai?.capabilities
+            }
+        } : (override.ai || base.ai),
+        paths: {
+            ...base.paths,
+            ...override.paths
+        },
+        development: {
+            ...base.development,
+            ...override.development
+        },
+        security: base.security && override.security ? {
+            ...base.security,
+            ...override.security,
+            filePermissions: {
+                ...base.security?.filePermissions,
+                ...override.security?.filePermissions
+            },
+            networkPermissions: {
+                ...base.security?.networkPermissions,
+                ...override.security?.networkPermissions
+            }
+        } : (override.security || base.security),
+        integrations: {
+            ...base.integrations,
+            ...override.integrations
+        }
+    };
+}
+/**
+ * Generate a unique workspace ID
+ */
+export function generateWorkspaceId() {
+    return `ws_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * Find available port for a service
+ */
+export function findAvailablePort(services, preferredPort, serviceType = 'backend') {
+    const usedPorts = new Set(Object.values(services).map(service => service.port));
+    // Try preferred port first
+    if (preferredPort && !usedPorts.has(preferredPort)) {
+        return preferredPort;
+    }
+    // Try common ports for the service type
+    const commonPorts = COMMON_SERVICE_PORTS.development[serviceType] || [];
+    for (const port of commonPorts) {
+        if (!usedPorts.has(port)) {
+            return port;
+        }
+    }
+    // Fall back to finding any available port in common ranges
+    const portRanges = [
+        { start: 3000, end: 3100 },
+        { start: 4000, end: 4100 },
+        { start: 5000, end: 5100 },
+        { start: 8000, end: 8100 }
+    ];
+    for (const range of portRanges) {
+        for (let port = range.start; port <= range.end; port++) {
+            if (!usedPorts.has(port)) {
+                return port;
+            }
+        }
+    }
+    throw new Error('No available ports found');
+}
+/**
+ * Resolve service dependencies in topological order
+ */
+export function resolveServiceDependencies(services) {
+    const resolved = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = (serviceId) => {
+        if (visiting.has(serviceId)) {
+            throw new Error(`Circular dependency detected involving service: ${serviceId}`);
+        }
+        if (visited.has(serviceId)) {
+            return;
+        }
+        visiting.add(serviceId);
+        const service = services[serviceId];
+        if (service?.dependencies) {
+            for (const dep of service.dependencies) {
+                if (dep.type === 'required' && services[dep.service]) {
+                    visit(dep.service);
+                }
+            }
+        }
+        visiting.delete(serviceId);
+        visited.add(serviceId);
+        resolved.push(serviceId);
+    };
+    for (const serviceId of Object.keys(services)) {
+        if (!visited.has(serviceId)) {
+            visit(serviceId);
+        }
+    }
+    return resolved;
+}
+/**
+ * Get service startup order based on dependencies
+ */
+export function getServiceStartupOrder(services) {
+    const levels = new Map();
+    const visited = new Set();
+    const calculateLevel = (serviceId) => {
+        if (levels.has(serviceId)) {
+            return levels.get(serviceId);
+        }
+        if (visited.has(serviceId)) {
+            throw new Error(`Circular dependency detected involving service: ${serviceId}`);
+        }
+        visited.add(serviceId);
+        const service = services[serviceId];
+        let maxDepLevel = 0;
+        if (service?.dependencies) {
+            for (const dep of service.dependencies) {
+                if (dep.type === 'required' && services[dep.service]) {
+                    const depLevel = calculateLevel(dep.service);
+                    maxDepLevel = Math.max(maxDepLevel, depLevel + 1);
+                }
+            }
+        }
+        levels.set(serviceId, maxDepLevel);
+        visited.delete(serviceId);
+        return maxDepLevel;
+    };
+    for (const serviceId of Object.keys(services)) {
+        calculateLevel(serviceId);
+    }
+    return Array.from(levels.entries())
+        .map(([service, level]) => ({ service, level }))
+        .sort((a, b) => a.level - b.level);
+}
+/**
+ * Validate service dependencies
+ */
+export function validateServiceDependencies(services) {
+    const issues = [];
+    for (const [serviceId, service] of Object.entries(services)) {
+        if (service.dependencies) {
+            for (const dep of service.dependencies) {
+                // Check if dependency exists
+                if (!services[dep.service]) {
+                    issues.push({
+                        service: serviceId,
+                        dependency: dep.service,
+                        issue: 'Dependency service not found'
+                    });
+                    continue;
+                }
+                // Check for self-dependency
+                if (dep.service === serviceId) {
+                    issues.push({
+                        service: serviceId,
+                        dependency: dep.service,
+                        issue: 'Service cannot depend on itself'
+                    });
+                }
+                // Version compatibility check (if versions are specified)
+                if (dep.version && services[dep.service].version) {
+                    if (!isVersionCompatible(services[dep.service].version, dep.version)) {
+                        issues.push({
+                            service: serviceId,
+                            dependency: dep.service,
+                            issue: `Version incompatibility: requires ${dep.version}, found ${services[dep.service].version}`
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Check if two versions are compatible (simplified semver check)
+ */
+export function isVersionCompatible(available, required) {
+    // Simple version comparison - in practice, use a proper semver library
+    const parseVersion = (v) => v.split('.').map(Number);
+    try {
+        const availableVer = parseVersion(available);
+        const requiredVer = parseVersion(required);
+        // Major version must match
+        if (availableVer[0] !== requiredVer[0]) {
+            return false;
+        }
+        // Minor version must be >= required
+        if (availableVer[1] < requiredVer[1]) {
+            return false;
+        }
+        // Patch version must be >= required if minor versions match
+        if (availableVer[1] === requiredVer[1] && availableVer[2] < requiredVer[2]) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        // If version parsing fails, assume compatible
+        return true;
+    }
+}
+/**
+ * Generate service health check URLs
+ */
+export function generateHealthCheckUrls(services) {
+    const healthChecks = {};
+    for (const [serviceId, service] of Object.entries(services)) {
+        if (service.healthCheck) {
+            healthChecks[serviceId] = service.healthCheck;
+        }
+        else {
+            // Generate default health check URL
+            const baseUrl = service.url.replace(/\/$/, '');
+            healthChecks[serviceId] = `${baseUrl}/health`;
+        }
+    }
+    return healthChecks;
+}
+/**
+ * Filter services by technology
+ */
+export function filterServicesByTechnology(services, technology) {
+    return Object.fromEntries(Object.entries(services).filter(([_, service]) => service.technology === technology));
+}
+/**
+ * Filter services by environment
+ */
+export function filterServicesByEnvironment(services, environment) {
+    return Object.fromEntries(Object.entries(services).filter(([_, service]) => service.environment === environment));
+}
+/**
+ * Get workspace summary
+ */
+export function getWorkspaceSummary(config) {
+    const services = Object.values(config.services);
+    const servicesByTechnology = services.reduce((acc, service) => {
+        acc[service.technology] = (acc[service.technology] || 0) + 1;
+        return acc;
+    }, {});
+    const servicesByEnvironment = services.reduce((acc, service) => {
+        acc[service.environment] = (acc[service.environment] || 0) + 1;
+        return acc;
+    }, {});
+    const totalDependencies = services.reduce((acc, service) => acc + (service.dependencies?.length || 0), 0);
+    return {
+        totalServices: services.length,
+        servicesByTechnology,
+        servicesByEnvironment,
+        dependencies: totalDependencies,
+        aiModels: Object.keys(config.ai.models).length,
+        pattern: config.workspace.pattern
+    };
+}
+/**
+ * Convert workspace config to environment variables
+ */
+export function workspaceConfigToEnvVars(config, prefix = 'TASK_SHEPHERD_') {
+    const envVars = {};
+    // Workspace metadata
+    envVars[`${prefix}WORKSPACE_ID`] = config.workspace.id;
+    envVars[`${prefix}WORKSPACE_NAME`] = config.workspace.name;
+    envVars[`${prefix}WORKSPACE_PATTERN`] = config.workspace.pattern;
+    // Service URLs and ports
+    for (const [serviceId, service] of Object.entries(config.services)) {
+        const servicePrefix = `${prefix}SERVICE_${serviceId.toUpperCase()}_`;
+        envVars[`${servicePrefix}URL`] = service.url;
+        envVars[`${servicePrefix}PORT`] = service.port.toString();
+        envVars[`${servicePrefix}PROTOCOL`] = service.protocol;
+    }
+    // AI configuration
+    envVars[`${prefix}AI_DEFAULT_MODEL`] = config.ai.defaultModel;
+    envVars[`${prefix}AI_MAX_CONCURRENT`] = config.ai.capabilities.maxConcurrentOperations.toString();
+    return envVars;
+}