@hyperdrive.bot/gut 0.1.8 → 0.1.10

package/dist/utils/display.js

@@ -0,0 +1,145 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import ora from 'ora';
+export const DisplayUtils = {
+    createSpinner(text) {
+        return ora(text);
+    },
+    createTable(options) {
+        return new Table({
+            style: { border: [], head: [] },
+            ...options,
+        });
+    },
+    error(message) {
+        console.log(chalk.red('✗'), message);
+    },
+    formatCommand(command) {
+        return chalk.cyan(`\`${command}\``);
+    },
+    formatDuration(ms) {
+        if (ms < 1000)
+            return `${ms}ms`;
+        if (ms < 60_000)
+            return `${(ms / 1000).toFixed(1)}s`;
+        if (ms < 3_600_000)
+            return `${(ms / 60_000).toFixed(1)}m`;
+        return `${(ms / 3_600_000).toFixed(1)}h`;
+    },
+    formatEntityType(type) {
+        const typeColors = {
+            delivery: chalk.blue,
+            module: chalk.green,
+            service: chalk.yellow,
+            tool: chalk.magenta,
+        };
+        const color = typeColors[type] || chalk.white;
+        return color(type);
+    },
+    formatGitStatus(status) {
+        const statusMap = {
+            '!': chalk.gray('!'), // Ignored
+            '?': chalk.gray('?'), // Untracked
+            A: chalk.green('A'), // Added
+            C: chalk.cyan('C'), // Copied
+            D: chalk.red('D'), // Deleted
+            M: chalk.yellow('M'), // Modified
+            R: chalk.blue('R'), // Renamed
+            U: chalk.magenta('U'), // Unmerged
+        };
+        return statusMap[status] || status;
+    },
+    formatList(items, maxItems = 5) {
+        if (items.length === 0)
+            return 'none';
+        if (items.length <= maxItems)
+            return items.join(', ');
+        const shown = items.slice(0, maxItems).join(', ');
+        const remaining = items.length - maxItems;
+        return `${shown}, and ${remaining} more`;
+    },
+    formatPath(path) {
+        return chalk.dim(path);
+    },
+    formatRelativeTime(date) {
+        const now = Date.now();
+        const then = date.getTime();
+        const diff = now - then;
+        const seconds = Math.floor(diff / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        const weeks = Math.floor(days / 7);
+        const months = Math.floor(days / 30);
+        const years = Math.floor(days / 365);
+        if (years > 0)
+            return `${years} ${this.pluralize(years, 'year')} ago`;
+        if (months > 0)
+            return `${months} ${this.pluralize(months, 'month')} ago`;
+        if (weeks > 0)
+            return `${weeks} ${this.pluralize(weeks, 'week')} ago`;
+        if (days > 0)
+            return `${days} ${this.pluralize(days, 'day')} ago`;
+        if (hours > 0)
+            return `${hours} ${this.pluralize(hours, 'hour')} ago`;
+        if (minutes > 0)
+            return `${minutes} ${this.pluralize(minutes, 'minute')} ago`;
+        return 'just now';
+    },
+    formatSize(bytes) {
+        const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+        let size = bytes;
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+            size /= 1024;
+            unitIndex++;
+        }
+        return `${size.toFixed(1)}${units[unitIndex]}`;
+    },
+    formatTimestamp(date) {
+        return date.toLocaleString();
+    },
+    highlight(text, pattern) {
+        const regex = typeof pattern === 'string'
+            ? new RegExp(pattern.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`), 'gi')
+            : pattern;
+        return text.replace(regex, match => chalk.yellow(match));
+    },
+    info(message) {
+        console.log(chalk.blue('ℹ'), message);
+    },
+    pluralize(count, singular, plural) {
+        return count === 1 ? singular : (plural || `${singular}s`);
+    },
+    printFooter(message, width = 50) {
+        console.log(chalk.dim('─'.repeat(width)));
+        if (message) {
+            console.log(chalk.dim(message));
+        }
+        console.log('');
+    },
+    printHeader(title, width = 50) {
+        console.log('');
+        console.log(chalk.bold(title));
+        console.log(chalk.dim('─'.repeat(width)));
+    },
+    progressBar(current, total, width = 20) {
+        const percentage = Math.min(100, Math.floor((current / total) * 100));
+        const filled = Math.floor((percentage / 100) * width);
+        const empty = width - filled;
+        const bar = '█'.repeat(filled) + '░'.repeat(empty);
+        return `${bar} ${percentage}%`;
+    },
+    success(message) {
+        console.log(chalk.green('✓'), message);
+    },
+    truncate(str, maxLength) {
+        if (str.length <= maxLength)
+            return str;
+        return str.slice(0, Math.max(0, maxLength - 3)) + '...';
+    },
+    warning(message) {
+        console.log(chalk.yellow('⚠'), message);
+    },
+};
+export default DisplayUtils;

package/dist/utils/filesystem.d.ts

@@ -0,0 +1,32 @@
+export declare const FileSystemUtils: {
+    copyDir(src: string, dest: string): Promise<void>;
+    copyFile(src: string, dest: string): Promise<void>;
+    createSymlink(target: string, linkPath: string): Promise<void>;
+    ensureDir(dirPath: string): Promise<void>;
+    exists(filePath: string): Promise<boolean>;
+    findFiles(dirPath: string, pattern: RegExp | string, options?: {
+        excludeDirs?: string[];
+        maxDepth?: number;
+        recursive?: boolean;
+    }): Promise<string[]>;
+    getBasename(filePath: string, ext?: string): string;
+    getCreatedTime(filePath: string): Promise<Date>;
+    getDirname(filePath: string): string;
+    getExtension(filePath: string): string;
+    getModifiedTime(filePath: string): Promise<Date>;
+    getSize(filePath: string): Promise<number>;
+    globToRegex(glob: string): RegExp;
+    isDirectory(filePath: string): Promise<boolean>;
+    isFile(filePath: string): Promise<boolean>;
+    isSymlink(filePath: string): Promise<boolean>;
+    joinPath(...paths: string[]): string;
+    makeExecutable(filePath: string): Promise<void>;
+    readJSON<T = unknown>(filePath: string): Promise<T>;
+    readSymlink(filePath: string): Promise<string>;
+    relativePath(from: string, to: string): string;
+    removeDir(dirPath: string): Promise<void>;
+    resolvePath(...paths: string[]): string;
+    touch(filePath: string): Promise<void>;
+    writeJSON(filePath: string, data: unknown, pretty?: boolean): Promise<void>;
+};
+export default FileSystemUtils;

package/dist/utils/filesystem.js

@@ -0,0 +1,198 @@
+import * as fs from 'node:fs';
+import path from 'node:path';
+const { mkdir, readdir, readFile, rmdir, stat, unlink, writeFile } = fs.promises;
+export const FileSystemUtils = {
+    async copyDir(src, dest) {
+        await this.ensureDir(dest);
+        const files = await readdir(src);
+        for (const file of files) {
+            const srcPath = path.join(src, file);
+            const destPath = path.join(dest, file);
+            const fileStat = await stat(srcPath);
+            await (fileStat.isDirectory() ? this.copyDir(srcPath, destPath) : this.copyFile(srcPath, destPath));
+        }
+    },
+    async copyFile(src, dest) {
+        const destDir = path.dirname(dest);
+        await this.ensureDir(destDir);
+        return new Promise((resolve, reject) => {
+            const readStream = fs.createReadStream(src);
+            const writeStream = fs.createWriteStream(dest);
+            readStream.on('error', reject);
+            writeStream.on('error', reject);
+            writeStream.on('finish', resolve);
+            readStream.pipe(writeStream);
+        });
+    },
+    async createSymlink(target, linkPath) {
+        await this.ensureDir(path.dirname(linkPath));
+        await fs.promises.symlink(target, linkPath);
+    },
+    async ensureDir(dirPath) {
+        try {
+            await mkdir(dirPath, { recursive: true });
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code !== 'EEXIST') {
+                throw error;
+            }
+        }
+    },
+    async exists(filePath) {
+        try {
+            await stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    async findFiles(dirPath, pattern, options = {}) {
+        const { excludeDirs = ['node_modules', '.git', 'dist', 'build'], maxDepth = 10, recursive = true, } = options;
+        const results = [];
+        const regex = typeof pattern === 'string'
+            ? new RegExp(pattern.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`))
+            : pattern;
+        const search = async (currentPath, depth) => {
+            if (depth > maxDepth)
+                return;
+            try {
+                const files = await readdir(currentPath);
+                for (const file of files) {
+                    const filePath = path.join(currentPath, file);
+                    const fileStat = await stat(filePath);
+                    if (fileStat.isDirectory()) {
+                        if (!excludeDirs.includes(file) && recursive) {
+                            await search(filePath, depth + 1);
+                        }
+                    }
+                    else if (regex.test(file)) {
+                        results.push(filePath);
+                    }
+                }
+            }
+            catch {
+                // Ignore permission errors
+            }
+        };
+        await search(dirPath, 0);
+        return results;
+    },
+    getBasename(filePath, ext) {
+        return path.basename(filePath, ext);
+    },
+    async getCreatedTime(filePath) {
+        const fileStat = await stat(filePath);
+        return fileStat.birthtime;
+    },
+    getDirname(filePath) {
+        return path.dirname(filePath);
+    },
+    getExtension(filePath) {
+        return path.extname(filePath);
+    },
+    async getModifiedTime(filePath) {
+        const fileStat = await stat(filePath);
+        return fileStat.mtime;
+    },
+    async getSize(filePath) {
+        const fileStat = await stat(filePath);
+        if (fileStat.isFile()) {
+            return fileStat.size;
+        }
+        if (fileStat.isDirectory()) {
+            let totalSize = 0;
+            const files = await readdir(filePath);
+            for (const file of files) {
+                const childPath = path.join(filePath, file);
+                totalSize += await this.getSize(childPath);
+            }
+            return totalSize;
+        }
+        return 0;
+    },
+    globToRegex(glob) {
+        const escaped = glob
+            .replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`)
+            .replaceAll(String.raw `\*`, '.*')
+            .replaceAll(String.raw `\?`, '.');
+        return new RegExp(`^${escaped}$`);
+    },
+    async isDirectory(filePath) {
+        try {
+            const fileStat = await stat(filePath);
+            return fileStat.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    },
+    async isFile(filePath) {
+        try {
+            const fileStat = await stat(filePath);
+            return fileStat.isFile();
+        }
+        catch {
+            return false;
+        }
+    },
+    async isSymlink(filePath) {
+        try {
+            const fileStat = await fs.promises.lstat(filePath);
+            return fileStat.isSymbolicLink();
+        }
+        catch {
+            return false;
+        }
+    },
+    joinPath(...paths) {
+        return path.join(...paths);
+    },
+    async makeExecutable(filePath) {
+        const currentMode = (await stat(filePath)).mode;
+        const newMode = currentMode | 0o111; // Add execute permission
+        await fs.promises.chmod(filePath, newMode);
+    },
+    async readJSON(filePath) {
+        const content = await readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    },
+    async readSymlink(filePath) {
+        return fs.promises.readlink(filePath);
+    },
+    relativePath(from, to) {
+        return path.relative(from, to);
+    },
+    async removeDir(dirPath) {
+        if (!fs.existsSync(dirPath))
+            return;
+        const files = await readdir(dirPath);
+        for (const file of files) {
+            const filePath = path.join(dirPath, file);
+            const fileStat = await stat(filePath);
+            await (fileStat.isDirectory() ? this.removeDir(filePath) : unlink(filePath));
+        }
+        await rmdir(dirPath);
+    },
+    resolvePath(...paths) {
+        return path.resolve(...paths);
+    },
+    async touch(filePath) {
+        const now = new Date();
+        try {
+            await fs.promises.utimes(filePath, now, now);
+        }
+        catch {
+            const handle = await fs.promises.open(filePath, 'w');
+            await handle.close();
+        }
+    },
+    async writeJSON(filePath, data, pretty = true) {
+        const content = pretty
+            ? JSON.stringify(data, null, 2)
+            : JSON.stringify(data);
+        await this.ensureDir(path.dirname(filePath));
+        await writeFile(filePath, content, 'utf8');
+    },
+};
+export default FileSystemUtils;

package/dist/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from './display.js';
+export * from './filesystem.js';
+export * from './validation.js';
+import DisplayUtilsDefault from './display.js';
+import FileSystemUtilsDefault from './filesystem.js';
+import ValidationUtilsDefault from './validation.js';
+export interface UtilsBundle {
+    display: typeof DisplayUtilsDefault;
+    filesystem: typeof FileSystemUtilsDefault;
+    validation: typeof ValidationUtilsDefault;
+}
+declare const utils: UtilsBundle;
+export default utils;

package/dist/utils/index.js

@@ -0,0 +1,14 @@
+// Re-export all named exports from each module (includes DisplayUtils, FileSystemUtils, ValidationUtils)
+export * from './display.js';
+export * from './filesystem.js';
+export * from './validation.js';
+// Also provide a combined default export for convenience
+import DisplayUtilsDefault from './display.js';
+import FileSystemUtilsDefault from './filesystem.js';
+import ValidationUtilsDefault from './validation.js';
+const utils = {
+    display: DisplayUtilsDefault,
+    filesystem: FileSystemUtilsDefault,
+    validation: ValidationUtilsDefault,
+};
+export default utils;

package/dist/utils/validation.d.ts

@@ -0,0 +1,22 @@
+export declare const ValidationUtils: {
+    detectProjectType(dirPath: string): null | string;
+    hasUncommittedChanges(dirPath: string): boolean;
+    isEmptyDirectory(dirPath: string): boolean;
+    isGitRepository(dirPath: string): boolean;
+    isGoProject(dirPath: string): boolean;
+    isJavaProject(dirPath: string): boolean;
+    isNodeProject(dirPath: string): boolean;
+    isPythonProject(dirPath: string): boolean;
+    isRustProject(dirPath: string): boolean;
+    isValidBranch(branch: string): boolean;
+    isValidEntityName(name: string): boolean;
+    isValidEntityType(type: string): boolean;
+    isValidGitUrl(url: string): boolean;
+    isValidPath(inputPath: string): boolean;
+    sanitizeGitUrl(url: string): string;
+    sanitizePath(inputPath: string): string;
+    validateConfig(config: Record<string, unknown>): string[];
+    validateEntityData(data: Record<string, unknown>): string[];
+    validateFocusEntities(entities: string[], availableEntities: string[]): string[];
+};
+export default ValidationUtils;

package/dist/utils/validation.js

@@ -0,0 +1,192 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+export const ValidationUtils = {
+    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;
+    },
+    hasUncommittedChanges(dirPath) {
+        if (!this.isGitRepository(dirPath)) {
+            return false;
+        }
+        try {
+            const status = execSync('git status --porcelain', {
+                cwd: dirPath,
+                encoding: 'utf8',
+                stdio: 'pipe',
+            });
+            return status.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    },
+    isEmptyDirectory(dirPath) {
+        try {
+            const files = fs.readdirSync(dirPath);
+            return files.length === 0
+                || (files.length === 1 && files[0] === '.git');
+        }
+        catch {
+            return true;
+        }
+    },
+    isGitRepository(dirPath) {
+        return fs.existsSync(path.join(dirPath, '.git'));
+    },
+    isGoProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'go.mod'));
+    },
+    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'));
+    },
+    isNodeProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'package.json'));
+    },
+    isPythonProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'requirements.txt'))
+            || fs.existsSync(path.join(dirPath, 'setup.py'))
+            || fs.existsSync(path.join(dirPath, 'pyproject.toml'));
+    },
+    isRustProject(dirPath) {
+        return fs.existsSync(path.join(dirPath, 'Cargo.toml'));
+    },
+    isValidBranch(branch) {
+        // Git branch naming rules
+        const invalidPatterns = [
+            /^\./, // Cannot start with .
+            /\.$/, // Cannot end with .
+            /\.\./, // Cannot contain ..
+            /\/\//, // Cannot contain //
+            /\s/, // Cannot contain spaces
+            /[\u0000-\u001F\u007F]/, // Cannot contain control characters
+            /[~^:?*[\\]/, // Cannot contain special characters
+        ];
+        return !invalidPatterns.some(pattern => pattern.test(branch))
+            && branch.length > 0
+            && branch.length <= 255;
+    },
+    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;
+    },
+    isValidEntityType(type) {
+        const validTypes = ['delivery', 'module', 'service', 'tool'];
+        return validTypes.includes(type);
+    },
+    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));
+    },
+    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;
+        }
+    },
+    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;
+    },
+    sanitizePath(inputPath) {
+        // Remove trailing slashes
+        let sanitized = inputPath.replace(/\/+$/, '');
+        // Normalize path separators
+        sanitized = sanitized.replaceAll('\\', '/');
+        // Remove redundant slashes
+        sanitized = sanitized.replaceAll(/\/+/g, '/');
+        return sanitized;
+    },
+    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) {
+            const focus = config.focus;
+            if (!Array.isArray(focus.entities)) {
+                errors.push('Focus entities must be an array');
+            }
+            if (!Array.isArray(focus.history)) {
+                errors.push('Focus history must be an array');
+            }
+        }
+        return errors;
+    },
+    validateEntityData(data) {
+        const errors = [];
+        if (!data.name) {
+            errors.push('Entity name is required');
+        }
+        else if (typeof data.name !== 'string' || !this.isValidEntityName(data.name)) {
+            errors.push('Invalid entity name format');
+        }
+        if (!data.type) {
+            errors.push('Entity type is required');
+        }
+        else if (typeof data.type !== 'string' || !this.isValidEntityType(data.type)) {
+            errors.push('Invalid entity type');
+        }
+        if (!data.path) {
+            errors.push('Entity path is required');
+        }
+        else if (typeof data.path !== 'string' || !this.isValidPath(data.path)) {
+            errors.push('Invalid entity path');
+        }
+        if (data.repository && (typeof data.repository !== 'string' || !this.isValidGitUrl(data.repository))) {
+            errors.push('Invalid repository URL');
+        }
+        return errors;
+    },
+    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;
+    },
+};
+export default ValidationUtils;