@hyperdrive.bot/gut 0.1.4 → 0.1.6

package/dist/services/git.service.js

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitService = void 0;
-const tslib_1 = require("tslib");
-const child_process_1 = require("child_process");
-const path = tslib_1.__importStar(require("path"));
-class GitService {
-    async exec(args, options) {
-        return new Promise((resolve, reject) => {
-            const gitProcess = (0, child_process_1.spawn)('git', args, {
-                cwd: options?.cwd || process.cwd(),
-                env: options?.env || process.env
-            });
-            let stdout = '';
-            let stderr = '';
-            gitProcess.stdout.on('data', (data) => {
-                stdout += data.toString();
-            });
-            gitProcess.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-            gitProcess.on('close', (code) => {
-                if (code === 0) {
-                    resolve(stdout);
-                }
-                else {
-                    reject(new Error(`Git command failed: ${stderr || stdout}`));
-                }
-            });
-            gitProcess.on('error', (error) => {
-                reject(error);
-            });
-        });
-    }
-    execSync(args, options) {
-        try {
-            return (0, child_process_1.execSync)(`git ${args.join(' ')}`, {
-                cwd: options?.cwd || process.cwd(),
-                env: options?.env || process.env,
-                encoding: 'utf8'
-            });
-        }
-        catch (error) {
-            throw new Error(`Git command failed: ${error.message}`);
-        }
-    }
-    async getStatus(repoPath) {
-        const branch = await this.getCurrentBranch(repoPath);
-        const statusOutput = await this.exec(['status', '--porcelain'], { cwd: repoPath });
-        const changes = [];
-        const untracked = [];
-        statusOutput.split('\n').forEach(line => {
-            if (line.startsWith('??')) {
-                untracked.push(line.substring(3));
-            }
-            else if (line.trim()) {
-                changes.push(line);
-            }
-        });
-        // Get ahead/behind info
-        let ahead = 0;
-        let behind = 0;
-        try {
-            const trackingBranch = await this.exec(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], { cwd: repoPath });
-            if (trackingBranch.trim()) {
-                const aheadBehind = await this.exec(['rev-list', '--left-right', '--count', `${trackingBranch.trim()}...HEAD`], { cwd: repoPath });
-                const [behindStr, aheadStr] = aheadBehind.trim().split('\t');
-                behind = parseInt(behindStr) || 0;
-                ahead = parseInt(aheadStr) || 0;
-            }
-        }
-        catch {
-            // No tracking branch
-        }
-        return {
-            entity: path.basename(repoPath),
-            path: repoPath,
-            branch,
-            ahead,
-            behind,
-            changes,
-            untracked,
-            hasChanges: changes.length > 0 || untracked.length > 0
-        };
-    }
-    async getCurrentBranch(repoPath) {
-        const branch = await this.exec(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoPath });
-        return branch.trim();
-    }
-    async add(repoPath, files) {
-        const args = ['add', ...files];
-        await this.exec(args, { cwd: repoPath });
-    }
-    async commit(repoPath, message, options) {
-        const args = ['commit'];
-        if (options?.all) {
-            args.push('-a');
-        }
-        if (options?.amend) {
-            args.push('--amend');
-        }
-        args.push('-m', message);
-        await this.exec(args, { cwd: repoPath });
-    }
-    async push(repoPath, options) {
-        const args = ['push'];
-        if (options?.force) {
-            args.push('--force');
-        }
-        if (options?.tags) {
-            args.push('--tags');
-        }
-        if (options?.setUpstream) {
-            const branch = await this.getCurrentBranch(repoPath);
-            args.push('--set-upstream', 'origin', branch);
-        }
-        await this.exec(args, { cwd: repoPath });
-    }
-    async pull(repoPath, options) {
-        const args = ['pull'];
-        if (options?.rebase) {
-            args.push('--rebase');
-        }
-        if (options?.noFf) {
-            args.push('--no-ff');
-        }
-        if (options?.strategy) {
-            args.push('--strategy', options.strategy);
-        }
-        await this.exec(args, { cwd: repoPath });
-    }
-    async fetch(repoPath) {
-        await this.exec(['fetch'], { cwd: repoPath });
-    }
-    async clone(url, destination, depth) {
-        const args = ['clone', url, destination];
-        if (depth) {
-            args.push('--depth', depth.toString());
-        }
-        await this.exec(args);
-    }
-    async isRepository(repoPath) {
-        try {
-            await this.exec(['rev-parse', '--git-dir'], { cwd: repoPath });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async hasChanges(repoPath) {
-        const status = await this.getStatus(repoPath);
-        return status.hasChanges;
-    }
-    async getRemoteUrl(repoPath, remote = 'origin') {
-        try {
-            const url = await this.exec(['remote', 'get-url', remote], { cwd: repoPath });
-            return url.trim();
-        }
-        catch {
-            return null;
-        }
-    }
-    async hasRemote(repoPath, remote = 'origin') {
-        try {
-            const remotes = await this.exec(['remote'], { cwd: repoPath });
-            return remotes.split('\n').includes(remote);
-        }
-        catch {
-            return false;
-        }
-    }
-    async addRemote(repoPath, name, url) {
-        await this.exec(['remote', 'add', name, url], { cwd: repoPath });
-    }
-    async init(repoPath) {
-        await this.exec(['init'], { cwd: repoPath });
-    }
-}
-exports.GitService = GitService;

package/dist/utils/display.d.ts

@@ -1,25 +0,0 @@
-import { Ora } from 'ora';
-export declare class DisplayUtils {
-    static createSpinner(text?: string): Ora;
-    static success(message: string): void;
-    static error(message: string): void;
-    static warning(message: string): void;
-    static info(message: string): void;
-    static createTable(options?: any): any;
-    static formatSize(bytes: number): string;
-    static formatDuration(ms: number): string;
-    static truncate(str: string, maxLength: number): string;
-    static pluralize(count: number, singular: string, plural?: string): string;
-    static formatList(items: string[], maxItems?: number): string;
-    static progressBar(current: number, total: number, width?: number): string;
-    static formatGitStatus(status: string): string;
-    static highlight(text: string, pattern: string | RegExp): string;
-    static formatEntityType(type: string): string;
-    static printHeader(title: string, width?: number): void;
-    static printFooter(message?: string, width?: number): void;
-    static formatCommand(command: string): string;
-    static formatPath(path: string): string;
-    static formatTimestamp(date: Date): string;
-    static formatRelativeTime(date: Date): string;
-}
-export default DisplayUtils;

package/dist/utils/display.js

@@ -1,150 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DisplayUtils = void 0;
-const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const ora_1 = tslib_1.__importDefault(require("ora"));
-const cli_table3_1 = tslib_1.__importDefault(require("cli-table3"));
-class DisplayUtils {
-    static createSpinner(text) {
-        return (0, ora_1.default)(text);
-    }
-    static success(message) {
-        console.log(chalk_1.default.green('✓'), message);
-    }
-    static error(message) {
-        console.log(chalk_1.default.red('✗'), message);
-    }
-    static warning(message) {
-        console.log(chalk_1.default.yellow('⚠'), message);
-    }
-    static info(message) {
-        console.log(chalk_1.default.blue('ℹ'), message);
-    }
-    static createTable(options) {
-        return new cli_table3_1.default({
-            style: { head: [], border: [] },
-            ...options,
-        });
-    }
-    static 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]}`;
-    }
-    static formatDuration(ms) {
-        if (ms < 1000)
-            return `${ms}ms`;
-        if (ms < 60000)
-            return `${(ms / 1000).toFixed(1)}s`;
-        if (ms < 3600000)
-            return `${(ms / 60000).toFixed(1)}m`;
-        return `${(ms / 3600000).toFixed(1)}h`;
-    }
-    static truncate(str, maxLength) {
-        if (str.length <= maxLength)
-            return str;
-        return str.substring(0, maxLength - 3) + '...';
-    }
-    static pluralize(count, singular, plural) {
-        return count === 1 ? singular : (plural || `${singular}s`);
-    }
-    static 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`;
-    }
-    static 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}%`;
-    }
-    static formatGitStatus(status) {
-        const statusMap = {
-            'M': chalk_1.default.yellow('M'), // Modified
-            'A': chalk_1.default.green('A'), // Added
-            'D': chalk_1.default.red('D'), // Deleted
-            'R': chalk_1.default.blue('R'), // Renamed
-            'C': chalk_1.default.cyan('C'), // Copied
-            'U': chalk_1.default.magenta('U'), // Unmerged
-            '?': chalk_1.default.gray('?'), // Untracked
-            '!': chalk_1.default.gray('!'), // Ignored
-        };
-        return statusMap[status] || status;
-    }
-    static highlight(text, pattern) {
-        const regex = typeof pattern === 'string'
-            ? new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi')
-            : pattern;
-        return text.replace(regex, match => chalk_1.default.yellow(match));
-    }
-    static formatEntityType(type) {
-        const typeColors = {
-            'delivery': chalk_1.default.blue,
-            'module': chalk_1.default.green,
-            'service': chalk_1.default.yellow,
-            'tool': chalk_1.default.magenta,
-        };
-        const color = typeColors[type] || chalk_1.default.white;
-        return color(type);
-    }
-    static printHeader(title, width = 50) {
-        console.log('');
-        console.log(chalk_1.default.bold(title));
-        console.log(chalk_1.default.dim('─'.repeat(width)));
-    }
-    static printFooter(message, width = 50) {
-        console.log(chalk_1.default.dim('─'.repeat(width)));
-        if (message) {
-            console.log(chalk_1.default.dim(message));
-        }
-        console.log('');
-    }
-    static formatCommand(command) {
-        return chalk_1.default.cyan(`\`${command}\``);
-    }
-    static formatPath(path) {
-        return chalk_1.default.dim(path);
-    }
-    static formatTimestamp(date) {
-        return date.toLocaleString();
-    }
-    static 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';
-    }
-}
-exports.DisplayUtils = DisplayUtils;
-exports.default = DisplayUtils;

package/dist/utils/filesystem.d.ts

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

package/dist/utils/filesystem.js

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemUtils = void 0;
-const tslib_1 = require("tslib");
-const fs = tslib_1.__importStar(require("fs"));
-const path = tslib_1.__importStar(require("path"));
-const util_1 = require("util");
-const readdir = (0, util_1.promisify)(fs.readdir);
-const stat = (0, util_1.promisify)(fs.stat);
-const readFile = (0, util_1.promisify)(fs.readFile);
-const writeFile = (0, util_1.promisify)(fs.writeFile);
-const mkdir = (0, util_1.promisify)(fs.mkdir);
-const rmdir = (0, util_1.promisify)(fs.rmdir);
-const unlink = (0, util_1.promisify)(fs.unlink);
-class FileSystemUtils {
-    static async ensureDir(dirPath) {
-        try {
-            await mkdir(dirPath, { recursive: true });
-        }
-        catch (error) {
-            if (error.code !== 'EEXIST') {
-                throw error;
-            }
-        }
-    }
-    static 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);
-            if (fileStat.isDirectory()) {
-                await this.removeDir(filePath);
-            }
-            else {
-                await unlink(filePath);
-            }
-        }
-        await rmdir(dirPath);
-    }
-    static 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);
-            if (fileStat.isDirectory()) {
-                await this.copyDir(srcPath, destPath);
-            }
-            else {
-                await this.copyFile(srcPath, destPath);
-            }
-        }
-    }
-    static 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);
-        });
-    }
-    static async findFiles(dirPath, pattern, options = {}) {
-        const { recursive = true, maxDepth = 10, excludeDirs = ['node_modules', '.git', 'dist', 'build'], } = options;
-        const results = [];
-        const regex = typeof pattern === 'string'
-            ? new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-            : 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 (error) {
-                // Ignore permission errors
-            }
-        };
-        await search(dirPath, 0);
-        return results;
-    }
-    static async readJSON(filePath) {
-        const content = await readFile(filePath, 'utf-8');
-        return JSON.parse(content);
-    }
-    static 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, 'utf-8');
-    }
-    static async exists(filePath) {
-        try {
-            await stat(filePath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    static async isDirectory(filePath) {
-        try {
-            const fileStat = await stat(filePath);
-            return fileStat.isDirectory();
-        }
-        catch {
-            return false;
-        }
-    }
-    static async isFile(filePath) {
-        try {
-            const fileStat = await stat(filePath);
-            return fileStat.isFile();
-        }
-        catch {
-            return false;
-        }
-    }
-    static 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;
-    }
-    static 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();
-        }
-    }
-    static async makeExecutable(filePath) {
-        const currentMode = (await stat(filePath)).mode;
-        const newMode = currentMode | 0o111; // Add execute permission
-        await fs.promises.chmod(filePath, newMode);
-    }
-    static resolvePath(...paths) {
-        return path.resolve(...paths);
-    }
-    static relativePath(from, to) {
-        return path.relative(from, to);
-    }
-    static getExtension(filePath) {
-        return path.extname(filePath);
-    }
-    static getBasename(filePath, ext) {
-        return path.basename(filePath, ext);
-    }
-    static getDirname(filePath) {
-        return path.dirname(filePath);
-    }
-    static joinPath(...paths) {
-        return path.join(...paths);
-    }
-    static async createSymlink(target, linkPath) {
-        await this.ensureDir(path.dirname(linkPath));
-        await fs.promises.symlink(target, linkPath);
-    }
-    static async isSymlink(filePath) {
-        try {
-            const fileStat = await fs.promises.lstat(filePath);
-            return fileStat.isSymbolicLink();
-        }
-        catch {
-            return false;
-        }
-    }
-    static async readSymlink(filePath) {
-        return await fs.promises.readlink(filePath);
-    }
-    static globToRegex(glob) {
-        const escaped = glob
-            .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-            .replace(/\\\*/g, '.*')
-            .replace(/\\\?/g, '.');
-        return new RegExp(`^${escaped}$`);
-    }
-    static async getModifiedTime(filePath) {
-        const fileStat = await stat(filePath);
-        return fileStat.mtime;
-    }
-    static async getCreatedTime(filePath) {
-        const fileStat = await stat(filePath);
-        return fileStat.birthtime;
-    }
-}
-exports.FileSystemUtils = FileSystemUtils;
-exports.default = FileSystemUtils;

package/dist/utils/index.d.ts

@@ -1,13 +0,0 @@
-export * from './display';
-export * from './validation';
-export * from './filesystem';
-import DisplayUtils from './display';
-import ValidationUtils from './validation';
-import FileSystemUtils from './filesystem';
-export { DisplayUtils, ValidationUtils, FileSystemUtils, };
-declare const _default: {
-    display: typeof DisplayUtils;
-    validation: typeof ValidationUtils;
-    filesystem: typeof FileSystemUtils;
-};
-export default _default;

package/dist/utils/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemUtils = exports.ValidationUtils = exports.DisplayUtils = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./display"), exports);
-tslib_1.__exportStar(require("./validation"), exports);
-tslib_1.__exportStar(require("./filesystem"), exports);
-const display_1 = tslib_1.__importDefault(require("./display"));
-exports.DisplayUtils = display_1.default;
-const validation_1 = tslib_1.__importDefault(require("./validation"));
-exports.ValidationUtils = validation_1.default;
-const filesystem_1 = tslib_1.__importDefault(require("./filesystem"));
-exports.FileSystemUtils = filesystem_1.default;
-exports.default = {
-    display: display_1.default,
-    validation: validation_1.default,
-    filesystem: filesystem_1.default,
-};

package/dist/utils/validation.d.ts

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