@task-shepherd/agent 1.0.7 → 1.0.11

package/shared/dist/workspace/utils.js

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