@hyperdrive.bot/gut 0.1.3

package/dist/utils/validation.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationUtils = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+class ValidationUtils {
+    static isValidEntityName(name) {
+        // Entity names should be alphanumeric with hyphens/underscores
+        const pattern = /^[a-zA-Z0-9]([a-zA-Z0-9-_]*[a-zA-Z0-9])?$/;
+        return pattern.test(name) && name.length <= 50;
+    }
+    static isValidEntityType(type) {
+        const validTypes = ['delivery', 'module', 'service', 'tool'];
+        return validTypes.includes(type);
+    }
+    static isValidPath(inputPath) {
+        try {
+            // Check if path is valid
+            path.parse(inputPath);
+            // Check for dangerous patterns
+            const dangerous = ['..', '~', '$', '`', '|', '&', ';', '>', '<'];
+            return !dangerous.some(pattern => inputPath.includes(pattern));
+        }
+        catch {
+            return false;
+        }
+    }
+    static isGitRepository(dirPath) {
+        return fs.existsSync(path.join(dirPath, '.git'));
+    }
+    static isValidGitUrl(url) {
+        const patterns = [
+            /^https?:\/\/.+\.git$/,
+            /^git@.+:.+\.git$/,
+            /^ssh:\/\/.+\.git$/,
+            /^https:\/\/github\.com\/.+\/.+$/,
+            /^https:\/\/gitlab\.com\/.+\/.+$/,
+            /^https:\/\/bitbucket\.org\/.+\/.+$/,
+        ];
+        return patterns.some(pattern => pattern.test(url));
+    }
+    static isValidBranch(branch) {
+        // Git branch naming rules
+        const invalidPatterns = [
+            /^\./, // Cannot start with .
+            /\.$/, // Cannot end with .
+            /\.\./, // Cannot contain ..
+            /\/\//, // Cannot contain //
+            /\s/, // Cannot contain spaces
+            /[\x00-\x1f\x7f]/, // Cannot contain control characters
+            /[~^:?*\[\\]/, // Cannot contain special characters
+        ];
+        return !invalidPatterns.some(pattern => pattern.test(branch)) &&
+            branch.length > 0 &&
+            branch.length <= 255;
+    }
+    static isNodeProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'package.json'));
+    }
+    static isPythonProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'requirements.txt')) ||
+            fs.existsSync(path.join(dirPath, 'setup.py')) ||
+            fs.existsSync(path.join(dirPath, 'pyproject.toml'));
+    }
+    static isGoProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'go.mod'));
+    }
+    static isRustProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'Cargo.toml'));
+    }
+    static isJavaProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'pom.xml')) ||
+            fs.existsSync(path.join(dirPath, 'build.gradle')) ||
+            fs.existsSync(path.join(dirPath, 'build.gradle.kts'));
+    }
+    static detectProjectType(dirPath) {
+        if (this.isNodeProject(dirPath))
+            return 'node';
+        if (this.isPythonProject(dirPath))
+            return 'python';
+        if (this.isGoProject(dirPath))
+            return 'go';
+        if (this.isRustProject(dirPath))
+            return 'rust';
+        if (this.isJavaProject(dirPath))
+            return 'java';
+        return null;
+    }
+    static validateEntityData(data) {
+        const errors = [];
+        if (!data.name) {
+            errors.push('Entity name is required');
+        }
+        else if (!this.isValidEntityName(data.name)) {
+            errors.push('Invalid entity name format');
+        }
+        if (!data.type) {
+            errors.push('Entity type is required');
+        }
+        else if (!this.isValidEntityType(data.type)) {
+            errors.push('Invalid entity type');
+        }
+        if (!data.path) {
+            errors.push('Entity path is required');
+        }
+        else if (!this.isValidPath(data.path)) {
+            errors.push('Invalid entity path');
+        }
+        if (data.repository && !this.isValidGitUrl(data.repository)) {
+            errors.push('Invalid repository URL');
+        }
+        return errors;
+    }
+    static validateFocusEntities(entities, availableEntities) {
+        const errors = [];
+        if (entities.length === 0) {
+            errors.push('At least one entity must be specified');
+        }
+        const unavailable = entities.filter(e => !availableEntities.includes(e));
+        if (unavailable.length > 0) {
+            errors.push(`Unknown entities: ${unavailable.join(', ')}`);
+        }
+        const duplicates = entities.filter((e, i) => entities.indexOf(e) !== i);
+        if (duplicates.length > 0) {
+            errors.push(`Duplicate entities: ${[...new Set(duplicates)].join(', ')}`);
+        }
+        return errors;
+    }
+    static sanitizePath(inputPath) {
+        // Remove trailing slashes
+        let sanitized = inputPath.replace(/\/+$/, '');
+        // Normalize path separators
+        sanitized = sanitized.replace(/\\/g, '/');
+        // Remove redundant slashes
+        sanitized = sanitized.replace(/\/+/g, '/');
+        return sanitized;
+    }
+    static sanitizeGitUrl(url) {
+        // Ensure .git extension for common providers
+        if (!url.endsWith('.git')) {
+            const providers = ['github.com', 'gitlab.com', 'bitbucket.org'];
+            if (providers.some(p => url.includes(p))) {
+                url += '.git';
+            }
+        }
+        return url;
+    }
+    static isEmptyDirectory(dirPath) {
+        try {
+            const files = fs.readdirSync(dirPath);
+            return files.length === 0 ||
+                (files.length === 1 && files[0] === '.git');
+        }
+        catch {
+            return true;
+        }
+    }
+    static hasUncommittedChanges(dirPath) {
+        if (!this.isGitRepository(dirPath)) {
+            return false;
+        }
+        try {
+            const { execSync } = require('child_process');
+            const status = execSync('git status --porcelain', {
+                cwd: dirPath,
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            return status.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    static validateConfig(config) {
+        const errors = [];
+        if (!config.workspace) {
+            errors.push('Workspace configuration is missing');
+        }
+        if (!config.entities || typeof config.entities !== 'object') {
+            errors.push('Entities configuration is invalid');
+        }
+        if (config.focus) {
+            if (!Array.isArray(config.focus.entities)) {
+                errors.push('Focus entities must be an array');
+            }
+            if (!Array.isArray(config.focus.history)) {
+                errors.push('Focus history must be an array');
+            }
+        }
+        return errors;
+    }
+}
+exports.ValidationUtils = ValidationUtils;
+exports.default = ValidationUtils;