@eldrforge/git-tools 0.1.3 → 0.1.4

package/src/index.ts

@@ -1,58 +0,0 @@
-/**
- * @eldrforge/git-tools
- *
- * Git utilities for automation - secure process execution and Git operations
- *
- * @module git-tools
- */
-
-// Export logger interface and functions
-export type { Logger } from './logger';
-export {
-    ConsoleLogger,
-    setLogger,
-    getLogger
-} from './logger';
-
-// Export child process execution functions
-export {
-    runSecure,
-    runSecureWithInheritedStdio,
-    run,
-    runWithInheritedStdio,
-    runWithDryRunSupport,
-    runSecureWithDryRunSupport,
-    validateGitRef,
-    validateFilePath,
-    escapeShellArg
-} from './child';
-
-// Export validation utilities
-export {
-    safeJsonParse,
-    validateString,
-    validateHasProperty,
-    validatePackageJson
-} from './validation';
-
-// Export git utilities
-export {
-    isValidGitRef,
-    findPreviousReleaseTag,
-    getCurrentVersion,
-    getDefaultFromRef,
-    getRemoteDefaultBranch,
-    localBranchExists,
-    remoteBranchExists,
-    getBranchCommitSha,
-    isBranchInSyncWithRemote,
-    safeSyncBranchWithRemote,
-    getCurrentBranch,
-    getGitStatusSummary,
-    getGloballyLinkedPackages,
-    getLinkedDependencies,
-    getLinkCompatibilityProblems,
-    getLinkProblems,
-    isNpmLinked
-} from './git';
-

package/src/logger.ts

@@ -1,81 +0,0 @@
-/**
- * Minimal logging interface that git-tools requires.
- * Allows consumers to provide their own logger implementation (e.g., Winston, console, etc.)
- */
-export interface Logger {
-    error(message: string, ...meta: any[]): void;
-    warn(message: string, ...meta: any[]): void;
-    info(message: string, ...meta: any[]): void;
-    verbose(message: string, ...meta: any[]): void;
-    debug(message: string, ...meta: any[]): void;
-}
-
-/**
- * Default console-based logger implementation
- */
-export class ConsoleLogger implements Logger {
-    constructor(private level: string = 'info') {}
-
-    private shouldLog(level: string): boolean {
-        const levels = ['error', 'warn', 'info', 'verbose', 'debug'];
-        const currentLevelIndex = levels.indexOf(this.level);
-        const messageLevelIndex = levels.indexOf(level);
-        return messageLevelIndex <= currentLevelIndex;
-    }
-
-    error(message: string, ...meta: any[]): void {
-        if (this.shouldLog('error')) {
-            // eslint-disable-next-line no-console
-            console.error(message, ...meta);
-        }
-    }
-
-    warn(message: string, ...meta: any[]): void {
-        if (this.shouldLog('warn')) {
-            // eslint-disable-next-line no-console
-            console.warn(message, ...meta);
-        }
-    }
-
-    info(message: string, ...meta: any[]): void {
-        if (this.shouldLog('info')) {
-            // eslint-disable-next-line no-console
-            console.info(message, ...meta);
-        }
-    }
-
-    verbose(message: string, ...meta: any[]): void {
-        if (this.shouldLog('verbose')) {
-            // eslint-disable-next-line no-console
-            console.log('[VERBOSE]', message, ...meta);
-        }
-    }
-
-    debug(message: string, ...meta: any[]): void {
-        if (this.shouldLog('debug')) {
-            // eslint-disable-next-line no-console
-            console.log('[DEBUG]', message, ...meta);
-        }
-    }
-}
-
-/**
- * Global logger instance - defaults to console logger
- * Use setLogger() to replace with your own implementation
- */
-let globalLogger: Logger = new ConsoleLogger();
-
-/**
- * Set the global logger instance
- */
-export function setLogger(logger: Logger): void {
-    globalLogger = logger;
-}
-
-/**
- * Get the global logger instance
- */
-export function getLogger(): Logger {
-    return globalLogger;
-}
-

package/src/validation.ts

@@ -1,62 +0,0 @@
-/**
- * Runtime validation utilities for safe type handling
- */
-
-/**
- * Safely parses JSON with error handling
- */
-export const safeJsonParse = <T = any>(jsonString: string, context?: string): T => {
-    try {
-        const parsed = JSON.parse(jsonString);
-        if (parsed === null || parsed === undefined) {
-            throw new Error('Parsed JSON is null or undefined');
-        }
-        return parsed;
-    } catch (error) {
-        const contextStr = context ? ` (${context})` : '';
-        throw new Error(`Failed to parse JSON${contextStr}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-};
-
-/**
- * Validates that a value is a non-empty string
- */
-export const validateString = (value: any, fieldName: string): string => {
-    if (typeof value !== 'string') {
-        throw new Error(`${fieldName} must be a string, got ${typeof value}`);
-    }
-    if (value.trim() === '') {
-        throw new Error(`${fieldName} cannot be empty`);
-    }
-    return value;
-};
-
-/**
- * Validates that a value exists and has a specific property
- */
-export const validateHasProperty = (obj: any, property: string, context?: string): void => {
-    if (!obj || typeof obj !== 'object') {
-        const contextStr = context ? ` in ${context}` : '';
-        throw new Error(`Object is null or not an object${contextStr}`);
-    }
-    if (!(property in obj)) {
-        const contextStr = context ? ` in ${context}` : '';
-        throw new Error(`Missing required property '${property}'${contextStr}`);
-    }
-};
-
-/**
- * Validates package.json structure has basic required fields
- */
-export const validatePackageJson = (data: any, context?: string, requireName: boolean = true): any => {
-    if (!data || typeof data !== 'object') {
-        const contextStr = context ? ` (${context})` : '';
-        throw new Error(`Invalid package.json${contextStr}: not an object`);
-    }
-    if (requireName && typeof data.name !== 'string') {
-        const contextStr = context ? ` (${context})` : '';
-        throw new Error(`Invalid package.json${contextStr}: name must be a string`);
-    }
-    return data;
-};
-

package/tests/child.integration.test.ts

@@ -1,170 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { runSecure, runSecureWithInheritedStdio, validateGitRef, validateFilePath, escapeShellArg } from '../src/child';
-
-/**
- * Integration tests that actually execute commands (not mocked)
- * These test the real implementation paths
- */
-describe('child.ts - integration tests', () => {
-    describe('runSecure', () => {
-        it('should execute simple echo command', async () => {
-            const { stdout } = await runSecure('echo', ['hello']);
-            expect(stdout.trim()).toBe('hello');
-        });
-
-        it('should handle multiple arguments', async () => {
-            const { stdout } = await runSecure('echo', ['hello', 'world']);
-            expect(stdout.trim()).toContain('hello');
-            expect(stdout.trim()).toContain('world');
-        });
-
-        it('should capture stderr', async () => {
-            // Use a command that writes to stderr
-            const { stderr } = await runSecure('node', ['-e', 'console.error("test error")']);
-            expect(stderr.trim()).toBe('test error');
-        });
-
-        it('should throw error for non-existent command', async () => {
-            await expect(runSecure('nonexistent-command-12345', [])).rejects.toThrow();
-        });
-
-        it('should throw error for command with non-zero exit code', async () => {
-            await expect(runSecure('node', ['-e', 'process.exit(1)'])).rejects.toThrow();
-        });
-
-        it('should handle empty args array', async () => {
-            const { stdout } = await runSecure('pwd', []);
-            expect(stdout).toBeTruthy();
-        });
-    });
-
-    describe('runSecureWithInheritedStdio', () => {
-        it('should execute command successfully', async () => {
-            await expect(runSecureWithInheritedStdio('echo', ['test'])).resolves.toBeUndefined();
-        });
-
-        it('should throw error for command with non-zero exit code', async () => {
-            await expect(runSecureWithInheritedStdio('node', ['-e', 'process.exit(1)'])).rejects.toThrow();
-        });
-
-        it('should throw error for non-existent command', async () => {
-            await expect(runSecureWithInheritedStdio('nonexistent-cmd-98765', [])).rejects.toThrow();
-        });
-    });
-
-    describe('validateGitRef', () => {
-        it('should return true for valid simple ref', () => {
-            expect(validateGitRef('main')).toBe(true);
-            expect(validateGitRef('feature-branch')).toBe(true);
-            expect(validateGitRef('v1.2.3')).toBe(true);
-        });
-
-        it('should return true for refs with slashes', () => {
-            expect(validateGitRef('refs/heads/main')).toBe(true);
-            expect(validateGitRef('origin/main')).toBe(true);
-            expect(validateGitRef('release/v1.2.x')).toBe(true);
-        });
-
-        it('should return true for refs with dots', () => {
-            expect(validateGitRef('v1.2.3')).toBe(true);
-            expect(validateGitRef('release/1.2.x')).toBe(true);
-        });
-
-        it('should return false for refs with double dots (directory traversal)', () => {
-            expect(validateGitRef('../etc/passwd')).toBe(false);
-            expect(validateGitRef('refs/../../../etc')).toBe(false);
-        });
-
-        it('should return false for refs starting with dash (flag injection)', () => {
-            expect(validateGitRef('-rf')).toBe(false);
-            expect(validateGitRef('--delete')).toBe(false);
-        });
-
-        it('should return false for refs with shell metacharacters', () => {
-            expect(validateGitRef('main; rm -rf /')).toBe(false);
-            expect(validateGitRef('main|cat /etc/passwd')).toBe(false);
-            expect(validateGitRef('main&whoami')).toBe(false);
-            expect(validateGitRef('main`whoami`')).toBe(false);
-            expect(validateGitRef('main$(whoami)')).toBe(false);
-        });
-
-        it('should return false for refs with spaces', () => {
-            expect(validateGitRef('main branch')).toBe(false);
-            expect(validateGitRef('feature test')).toBe(false);
-        });
-
-        it('should return false for refs with brackets', () => {
-            expect(validateGitRef('main[test]')).toBe(false);
-            expect(validateGitRef('branch{test}')).toBe(false);
-        });
-
-        it('should return true for valid refs with underscores', () => {
-            expect(validateGitRef('feature_branch')).toBe(true);
-            expect(validateGitRef('test_123')).toBe(true);
-        });
-
-        it('should return true for valid refs with numbers', () => {
-            expect(validateGitRef('v1234567890')).toBe(true);
-            expect(validateGitRef('release123')).toBe(true);
-        });
-    });
-
-    describe('validateFilePath', () => {
-        it('should return true for valid file paths', () => {
-            expect(validateFilePath('/path/to/file.txt')).toBe(true);
-            expect(validateFilePath('./relative/path.js')).toBe(true);
-            expect(validateFilePath('../parent/file.md')).toBe(true);
-        });
-
-        it('should return false for paths with shell metacharacters', () => {
-            expect(validateFilePath('/path;rm -rf /')).toBe(false);
-            expect(validateFilePath('/path|cat /etc/passwd')).toBe(false);
-            expect(validateFilePath('/path&whoami')).toBe(false);
-            expect(validateFilePath('/path`whoami`')).toBe(false);
-            expect(validateFilePath('/path$(whoami)')).toBe(false);
-        });
-
-        it('should return false for paths with brackets', () => {
-            expect(validateFilePath('/path[test]')).toBe(false);
-            expect(validateFilePath('/path{test}')).toBe(false);
-        });
-
-        it('should return true for paths with spaces and dots', () => {
-            expect(validateFilePath('/path with spaces/file.txt')).toBe(true);
-            expect(validateFilePath('/path/to/../file.txt')).toBe(true);
-            expect(validateFilePath('./file.txt')).toBe(true);
-        });
-    });
-
-    describe('escapeShellArg', () => {
-        it('should escape single quotes on Unix', () => {
-            if (process.platform !== 'win32') {
-                const result = escapeShellArg("test'string");
-                expect(result).toContain("'\\''");
-            }
-        });
-
-        it('should escape double quotes on Windows', () => {
-            if (process.platform === 'win32') {
-                const result = escapeShellArg('test"string');
-                expect(result).toContain('\\"');
-            }
-        });
-
-        it('should handle normal strings without special chars', () => {
-            const result = escapeShellArg('normal-string-123');
-            expect(result).toBeTruthy();
-        });
-
-        it('should handle empty string', () => {
-            const result = escapeShellArg('');
-            expect(result).toBeTruthy();
-        });
-
-        it('should handle strings with spaces', () => {
-            const result = escapeShellArg('string with spaces');
-            expect(result).toBeTruthy();
-        });
-    });
-});
-