resulgit 1.0.3 → 1.0.5

package/README.md

@@ -39,6 +39,7 @@ resulgit <command> [options]
 
 ### Clone & Workspace
 
+- `resulgit init [--dir <path>] [--repo <id>] [--server <url>] [--branch <name>] [--token <token>]` - Initialize a new repository
 - `resulgit clone --repo <id> --branch <name> [--dest <dir>]` - Clone a repository
 - `resulgit workspace set-root --path <dir>` - Set workspace root directory
 
@@ -130,6 +131,9 @@ resulgit auth login --email user@example.com --password mypassword
 # List repositories
 resulgit repo list
 
+# Initialize a new repository
+resulgit init --repo 123 --branch main
+
 # Clone a repository
 resulgit clone --repo 123 --branch main
 

package/lib/blame.js

@@ -0,0 +1,79 @@
+/**
+ * Git Blame Implementation
+ * Shows line-by-line authorship information for files
+ */
+
+/**
+ * Parse blame data from commit history
+ */
+function parseBlame(fileContent, commits, filePath) {
+    const lines = fileContent.split(/\r?\n/)
+    const blameData = []
+
+    // For simplicity, we'll attribute all lines to the most recent commit
+    // In a full implementation, we'd track line-by-line changes through history
+    const latestCommit = commits.length > 0 ? commits[0] : null
+
+    for (let i = 0; i < lines.length; i++) {
+        blameData.push({
+            lineNumber: i + 1,
+            commitId: latestCommit?.id || latestCommit?._id || 'uncommitted',
+            author: latestCommit?.author?.name || 'Unknown',
+            authorEmail: latestCommit?.author?.email || '',
+            date: latestCommit?.createdAt || latestCommit?.committer?.date || new Date().toISOString(),
+            content: lines[i]
+        })
+    }
+
+    return blameData
+}
+
+/**
+ * Format blame output for terminal
+ */
+function formatBlameOutput(blameData, options = {}) {
+    const { colors = true } = options
+    const COLORS = {
+        reset: '\x1b[0m',
+        dim: '\x1b[2m',
+        cyan: '\x1b[36m',
+        yellow: '\x1b[33m',
+        green: '\x1b[32m'
+    }
+
+    const lines = []
+    const maxLineNum = String(blameData.length).length
+
+    for (const line of blameData) {
+        const lineNum = String(line.lineNumber).padStart(maxLineNum, ' ')
+        const commitShort = line.commitId.slice(0, 8)
+        const author = line.author.slice(0, 20).padEnd(20, ' ')
+        const date = new Date(line.date).toISOString().split('T')[0]
+
+        if (colors) {
+            const formatted = `${COLORS.dim}${lineNum}${COLORS.reset} ` +
+                `${COLORS.yellow}${commitShort}${COLORS.reset} ` +
+                `${COLORS.cyan}${author}${COLORS.reset} ` +
+                `${COLORS.green}${date}${COLORS.reset} ` +
+                `${line.content}`
+            lines.push(formatted)
+        } else {
+            lines.push(`${lineNum} ${commitShort} ${author} ${date} ${line.content}`)
+        }
+    }
+
+    return lines.join('\n')
+}
+
+/**
+ * Format blame output as JSON
+ */
+function formatBlameJson(blameData) {
+    return JSON.stringify(blameData, null, 2)
+}
+
+module.exports = {
+    parseBlame,
+    formatBlameOutput,
+    formatBlameJson
+}

package/lib/errors.js

@@ -0,0 +1,213 @@
+/**
+ * Custom Error Classes for ResulGit
+ * Provides specific error types for better error handling and user feedback
+ */
+
+/**
+ * Base error class for ResulGit
+ */
+class ResulGitError extends Error {
+    constructor(message, code, details = {}) {
+        super(message)
+        this.name = 'ResulGitError'
+        this.code = code
+        this.details = details
+        Error.captureStackTrace(this, this.constructor)
+    }
+
+    toJSON() {
+        return {
+            error: this.name,
+            code: this.code,
+            message: this.message,
+            details: this.details
+        }
+    }
+}
+
+/**
+ * Validation error
+ */
+class ValidationError extends ResulGitError {
+    constructor(message, field) {
+        super(message, 'VALIDATION_ERROR', { field })
+        this.name = 'ValidationError'
+    }
+}
+
+/**
+ * Authentication error
+ */
+class AuthenticationError extends ResulGitError {
+    constructor(message) {
+        super(message, 'AUTH_ERROR')
+        this.name = 'AuthenticationError'
+    }
+}
+
+/**
+ * Repository not found error
+ */
+class RepositoryNotFoundError extends ResulGitError {
+    constructor(repoId) {
+        super(`Repository not found: ${repoId}`, 'REPO_NOT_FOUND', { repoId })
+        this.name = 'RepositoryNotFoundError'
+    }
+}
+
+/**
+ * Branch not found error
+ */
+class BranchNotFoundError extends ResulGitError {
+    constructor(branchName, repoId) {
+        super(`Branch not found: ${branchName}`, 'BRANCH_NOT_FOUND', { branchName, repoId })
+        this.name = 'BranchNotFoundError'
+    }
+}
+
+/**
+ * Commit not found error
+ */
+class CommitNotFoundError extends ResulGitError {
+    constructor(commitId) {
+        super(`Commit not found: ${commitId}`, 'COMMIT_NOT_FOUND', { commitId })
+        this.name = 'CommitNotFoundError'
+    }
+}
+
+/**
+ * Merge conflict error
+ */
+class ConflictError extends ResulGitError {
+    constructor(conflicts) {
+        const fileList = conflicts.map(c => c.path).join(', ')
+        super(`Merge conflicts in files: ${fileList}`, 'MERGE_CONFLICT', { conflicts })
+        this.name = 'ConflictError'
+    }
+}
+
+/**
+ * Network error
+ */
+class NetworkError extends ResulGitError {
+    constructor(message, statusCode, url) {
+        super(message, 'NETWORK_ERROR', { statusCode, url })
+        this.name = 'NetworkError'
+    }
+}
+
+/**
+ * File system error
+ */
+class FileSystemError extends ResulGitError {
+    constructor(message, path, operation) {
+        super(message, 'FS_ERROR', { path, operation })
+        this.name = 'FileSystemError'
+    }
+}
+
+/**
+ * Configuration error
+ */
+class ConfigurationError extends ResulGitError {
+    constructor(message, configKey) {
+        super(message, 'CONFIG_ERROR', { configKey })
+        this.name = 'ConfigurationError'
+    }
+}
+
+/**
+ * Remote repository error
+ */
+class RemoteError extends ResulGitError {
+    constructor(message) {
+        super(message, 'REMOTE_ERROR')
+        this.name = 'RemoteError'
+    }
+}
+
+/**
+ * Format error for display
+ */
+function formatError(err, jsonMode = false) {
+    if (jsonMode) {
+        if (err instanceof ResulGitError) {
+            return JSON.stringify(err.toJSON(), null, 2)
+        }
+        return JSON.stringify({
+            error: 'Error',
+            message: err.message,
+            code: err.code || 'UNKNOWN_ERROR'
+        }, null, 2)
+    }
+
+    // Colorized output for terminal
+    const COLORS = {
+        red: '\x1b[31m',
+        yellow: '\x1b[33m',
+        reset: '\x1b[0m',
+        bold: '\x1b[1m'
+    }
+
+    let output = `${COLORS.bold}${COLORS.red}Error:${COLORS.reset} ${err.message}\n`
+
+    if (err instanceof ResulGitError && err.code) {
+        output += `${COLORS.yellow}Code:${COLORS.reset} ${err.code}\n`
+    }
+
+    if (err instanceof ConflictError && err.details.conflicts) {
+        output += `${COLORS.yellow}Conflicts:${COLORS.reset}\n`
+        for (const conflict of err.details.conflicts) {
+            output += `  - ${conflict.path}${conflict.line ? `:${conflict.line}` : ''}\n`
+        }
+    }
+
+    return output
+}
+
+/**
+ * Wrap async function with error handling
+ */
+function wrapAsync(fn) {
+    return async function (...args) {
+        try {
+            return await fn(...args)
+        } catch (err) {
+            if (err instanceof ResulGitError) {
+                throw err
+            }
+
+            // Convert common errors to ResulGit errors
+            if (err.code === 'ENOENT') {
+                throw new FileSystemError(`File or directory not found: ${err.path}`, err.path, 'read')
+            }
+
+            if (err.code === 'EACCES') {
+                throw new FileSystemError(`Permission denied: ${err.path}`, err.path, 'access')
+            }
+
+            if (err.message && err.message.includes('fetch failed')) {
+                throw new NetworkError(err.message, null, null)
+            }
+
+            // Re-throw unknown errors
+            throw err
+        }
+    }
+}
+
+module.exports = {
+    ResulGitError,
+    ValidationError,
+    AuthenticationError,
+    RepositoryNotFoundError,
+    BranchNotFoundError,
+    CommitNotFoundError,
+    ConflictError,
+    NetworkError,
+    FileSystemError,
+    ConfigurationError,
+    RemoteError,
+    formatError,
+    wrapAsync
+}

package/lib/hooks.js

@@ -0,0 +1,251 @@
+/**
+ * Git Hooks System
+ * Allows execution of custom scripts at specific points in the Git workflow
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const { exec } = require('child_process')
+const util = require('util')
+const execPromise = util.promisify(exec)
+
+/**
+ * Available hook types
+ */
+const HOOK_TYPES = [
+    'pre-commit',
+    'post-commit',
+    'pre-push',
+    'post-push',
+    'pre-merge',
+    'post-merge',
+    'pre-checkout',
+    'post-checkout'
+]
+
+/**
+ * Get hooks directory path
+ */
+function getHooksDir(repoDir) {
+    return path.join(repoDir, '.git', 'hooks')
+}
+
+/**
+ * Check if a hook exists
+ */
+async function hookExists(repoDir, hookName) {
+    if (!HOOK_TYPES.includes(hookName)) {
+        throw new Error(`Invalid hook type: ${hookName}. Valid types: ${HOOK_TYPES.join(', ')}`)
+    }
+
+    const hooksDir = getHooksDir(repoDir)
+    const hookPath = path.join(hooksDir, hookName)
+
+    try {
+        const stat = await fs.stat(hookPath)
+        return stat.isFile()
+    } catch {
+        return false
+    }
+}
+
+/**
+ * Execute a hook
+ */
+async function executeHook(repoDir, hookName, context = {}) {
+    if (!await hookExists(repoDir, hookName)) {
+        return { executed: false, output: null, error: null }
+    }
+
+    const hookPath = path.join(getHooksDir(repoDir), hookName)
+
+    try {
+        // Check if file is executable
+        const stat = await fs.stat(hookPath)
+        const isExecutable = (stat.mode & 0o111) !== 0
+
+        if (!isExecutable) {
+            return { executed: false, output: null, error: 'Hook is not executable' }
+        }
+
+        // Pass context as environment variables
+        const env = {
+            ...process.env,
+            RESULGIT_HOOK: hookName,
+            RESULGIT_REPO_DIR: repoDir,
+            ...Object.fromEntries(
+                Object.entries(context).map(([k, v]) => [`RESULGIT_${k.toUpperCase()}`, String(v)])
+            )
+        }
+
+        // Execute the hook
+        const { stdout, stderr } = await execPromise(hookPath, {
+            cwd: repoDir,
+            env,
+            timeout: 60000 // 60 second timeout
+        })
+
+        return {
+            executed: true,
+            output: stdout,
+            error: stderr || null,
+            exitCode: 0
+        }
+    } catch (err) {
+        return {
+            executed: true,
+            output: err.stdout || '',
+            error: err.stderr || err.message,
+            exitCode: err.code || 1
+        }
+    }
+}
+
+/**
+ * Install a hook
+ */
+async function installHook(repoDir, hookName, script) {
+    if (!HOOK_TYPES.includes(hookName)) {
+        throw new Error(`Invalid hook type: ${hookName}`)
+    }
+
+    const hooksDir = getHooksDir(repoDir)
+    await fs.mkdir(hooksDir, { recursive: true })
+
+    const hookPath = path.join(hooksDir, hookName)
+
+    // Ensure script has shebang
+    let finalScript = script
+    if (!script.startsWith('#!')) {
+        finalScript = '#!/bin/sh\n' + script
+    }
+
+    await fs.writeFile(hookPath, finalScript, { mode: 0o755 })
+
+    return { installed: true, path: hookPath }
+}
+
+/**
+ * Remove a hook
+ */
+async function removeHook(repoDir, hookName) {
+    if (!HOOK_TYPES.includes(hookName)) {
+        throw new Error(`Invalid hook type: ${hookName}`)
+    }
+
+    const hookPath = path.join(getHooksDir(repoDir), hookName)
+
+    try {
+        await fs.unlink(hookPath)
+        return { removed: true }
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            return { removed: false, error: 'Hook does not exist' }
+        }
+        throw err
+    }
+}
+
+/**
+ * ListAll hooks
+ */
+async function listHooks(repoDir) {
+    const hooksDir = getHooksDir(repoDir)
+    const hooks = []
+
+    try {
+        const files = await fs.readdir(hooksDir)
+
+        for (const file of files) {
+            if (HOOK_TYPES.includes(file)) {
+                const hookPath = path.join(hooksDir, file)
+                const stat = await fs.stat(hookPath)
+                const isExecutable = (stat.mode & 0o111) !== 0
+
+                hooks.push({
+                    name: file,
+                    path: hookPath,
+                    executable: isExecutable,
+                    size: stat.size
+                })
+            }
+        }
+    } catch (err) {
+        if (err.code !== 'ENOENT') {
+            throw err
+        }
+    }
+
+    return hooks
+}
+
+/**
+ * Read hook content
+ */
+async function readHook(repoDir, hookName) {
+    if (!HOOK_TYPES.includes(hookName)) {
+        throw new Error(`Invalid hook type: ${hookName}`)
+    }
+
+    const hookPath = path.join(getHooksDir(repoDir), hookName)
+
+    try {
+        const content = await fs.readFile(hookPath, 'utf8')
+        return { content, path: hookPath }
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            return { content: null, error: 'Hook does not exist' }
+        }
+        throw err
+    }
+}
+
+/**
+ * Sample hooks for common use cases
+ */
+const SAMPLE_HOOKS = {
+    'pre-commit': `#!/bin/sh
+# Pre-commit hook: Run linting before commit
+echo "Running pre-commit checks..."
+
+# Example: Run linter
+# npm run lint
+# if [ $? -ne 0 ]; then
+#   echo "Linting failed. Commit aborted."
+#   exit 1
+# fi
+
+echo "Pre-commit checks passed!"
+exit 0
+`,
+    'post-commit': `#!/bin/sh
+# Post-commit hook: Log commit info
+echo "Commit completed: $(git log -1 --pretty=%B)"
+exit 0
+`,
+    'pre-push': `#!/bin/sh
+# Pre-push hook: Run tests before push
+echo "Running tests before push..."
+
+# Example: Run tests
+# npm test
+# if [ $? -ne 0 ]; then
+#   echo "Tests failed. Push aborted."
+#   exit 1
+# fi
+
+echo "Tests passed!"
+exit 0
+`
+}
+
+module.exports = {
+    HOOK_TYPES,
+    hookExists,
+    executeHook,
+    installHook,
+    removeHook,
+    listHooks,
+    readHook,
+    SAMPLE_HOOKS
+}

package/lib/log-viz.js

@@ -0,0 +1,188 @@
+/**
+ * Git Log Visualization
+ * Creates ASCII graph visualization of commit history
+ */
+
+/**
+ * Generate ASCII graph for commit history
+ */
+function generateLogGraph(commits, options = {}) {
+    const { includeGraph = true, colors = true, maxCommits = 50 } = options
+
+    const COLORS = {
+        reset: '\x1b[0m',
+        yellow: '\x1b[33m',
+        cyan: '\x1b[36m',
+        green: '\x1b[32m',
+        blue: '\x1b[34m',
+        red: '\x1b[31m',
+        dim: '\x1b[2m',
+        bold: '\x1b[1m'
+    }
+
+    const limitedCommits = commits.slice(0, maxCommits)
+    const lines = []
+
+    for (let i = 0; i < limitedCommits.length; i++) {
+        const commit = limitedCommits[i]
+        const isFirst = i === 0
+        const isLast = i === limitedCommits.length - 1
+
+        // Graph symbols
+        let graph = ''
+        if (includeGraph) {
+            if (isFirst) {
+                graph = '* '
+            } else if (isLast) {
+                graph = '* '
+            } else {
+                graph = '* '
+            }
+
+            // Add branch lines
+            if (!isLast) {
+                graph = `${graph}`
+            }
+        }
+
+        // Commit ID
+        const commitId = (commit.id || commit._id || '').slice(0, 7)
+        const coloredId = colors ? `${COLORS.yellow}${commitId}${COLORS.reset}` : commitId
+
+        // Author
+        const author = commit.author?.name || 'Unknown'
+        const authorShort = author.slice(0, 20)
+        const coloredAuthor = colors ? `${COLORS.cyan}${authorShort}${COLORS.reset}` : authorShort
+
+        // Date
+        const date = commit.createdAt || commit.committer?.date || ''
+        const dateObj = new Date(date)
+        const relativeDate = getRelativeDate(dateObj)
+        const coloredDate = colors ? `${COLORS.green}${relativeDate}${COLORS.reset}` : relativeDate
+
+        // Message
+        const message = (commit.message || 'No message').split('\n')[0].slice(0, 80)
+        const coloredMessage = colors ? `${COLORS.bold}${message}${COLORS.reset}` : message
+
+        // Branch tags (if any)
+        const tags = []
+        if (commit.branches && commit.branches.length > 0) {
+            tags.push(...commit.branches.map(b => `branch: ${b}`))
+        }
+        if (commit.tags && commit.tags.length > 0) {
+            tags.push(...commit.tags.map(t => `tag: ${t}`))
+        }
+
+        let tagStr = ''
+        if (tags.length > 0) {
+            const tagText = tags.join(', ')
+            tagStr = colors ? ` ${COLORS.red}(${tagText})${COLORS.reset}` : ` (${tagText})`
+        }
+
+        // Construct line
+        const line = `${graph}${coloredId} - ${coloredMessage}${tagStr} ${COLORS.dim}${coloredDate} ${coloredAuthor}${COLORS.reset}`
+        lines.push(line)
+
+        // Add connecting line if not last
+        if (!isLast && includeGraph) {
+            lines.push('|')
+        }
+    }
+
+    if (commits.length > maxCommits) {
+        lines.push('')
+        lines.push(`... ${commits.length - maxCommits} more commits`)
+    }
+
+    return lines.join('\n')
+}
+
+/**
+ * Get relative date string
+ */
+function getRelativeDate(date) {
+    const now = new Date()
+    const diffMs = now - date
+    const diffSecs = Math.floor(diffMs / 1000)
+    const diffMins = Math.floor(diffSecs / 60)
+    const diffHours = Math.floor(diffMins / 60)
+    const diffDays = Math.floor(diffHours / 24)
+    const diffWeeks = Math.floor(diffDays / 7)
+    const diffMonths = Math.floor(diffDays / 30)
+    const diffYears = Math.floor(diffDays / 365)
+
+    if (diffYears > 0) return `${diffYears} year${diffYears > 1 ? 's' : ''} ago`
+    if (diffMonths > 0) return `${diffMonths} month${diffMonths > 1 ? 's' : ''} ago`
+    if (diffWeeks > 0) return `${diffWeeks} week${diffWeeks > 1 ? 's' : ''} ago`
+    if (diffDays > 0) return `${diffDays} day${diffDays > 1 ? 's' : ''} ago`
+    if (diffHours > 0) return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`
+    if (diffMins > 0) return `${diffMins} minute${diffMins > 1 ? 's' : ''} ago`
+    return 'just now'
+}
+
+/**
+ * Format compact log (one line per commit)
+ */
+function formatCompactLog(commits, colors = true) {
+    const COLORS = {
+        reset: '\x1b[0m',
+        yellow: '\x1b[33m',
+        dim: '\x1b[2m'
+    }
+
+    return commits.map(commit => {
+        const id = (commit.id || commit._id || '').slice(0, 7)
+        const message = (commit.message || 'No message').split('\n')[0].slice(0, 60)
+
+        if (colors) {
+            return `${COLORS.yellow}${id}${COLORS.reset} ${message}`
+        }
+        return `${id} ${message}`
+    }).join('\n')
+}
+
+/**
+ * Generate commit statistics
+ */
+function generateCommitStats(commits) {
+    const stats = {
+        totalCommits: commits.length,
+        authors: {},
+        datesRange: { earliest: null, latest: null },
+        commitsPerDay: {}
+    }
+
+    for (const commit of commits) {
+        // Author stats
+        const authorName = commit.author?.name || 'Unknown'
+        stats.authors[authorName] = (stats.authors[authorName] || 0) + 1
+
+        // Date stats
+        const date = new Date(commit.createdAt || commit.committer?.date || new Date())
+        if (!stats.datesRange.earliest || date < stats.datesRange.earliest) {
+            stats.datesRange.earliest = date
+        }
+        if (!stats.datesRange.latest || date > stats.datesRange.latest) {
+            stats.datesRange.latest = date
+        }
+
+        // Commits per day
+        const dayKey = date.toISOString().split('T')[0]
+        stats.commitsPerDay[dayKey] = (stats.commitsPerDay[dayKey] || 0) + 1
+    }
+
+    // Sort authors by commit count
+    stats.topAuthors = Object.entries(stats.authors)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 5)
+        .map(([name, count]) => ({ name, commits: count }))
+
+    return stats
+}
+
+module.exports = {
+    generateLogGraph,
+    formatCompactLog,
+    generateCommitStats,
+    getRelativeDate
+}

package/lib/validation.js

@@ -0,0 +1,260 @@
+/**
+ * Input Validation Module
+ * Provides validation functions for user inputs to prevent security issues
+ */
+
+const path = require('path')
+
+/**
+ * Validates repository ID format
+ */
+function validateRepoId(repoId) {
+    if (!repoId || typeof repoId !== 'string') {
+        throw new Error('Invalid repository ID: must be a non-empty string')
+    }
+
+    // Allow alphanumeric, hyphens, underscores, and UUIDs
+    const validPattern = /^[a-zA-Z0-9_-]+$/
+    if (!validPattern.test(repoId)) {
+        throw new Error('Invalid repository ID: contains invalid characters')
+    }
+
+    if (repoId.length > 100) {
+        throw new Error('Invalid repository ID: too long (max 100 characters)')
+    }
+
+    return repoId.trim()
+}
+
+/**
+ * Validates branch name format
+ */
+function validateBranchName(branchName) {
+    if (!branchName || typeof branchName !== 'string') {
+        throw new Error('Invalid branch name: must be a non-empty string')
+    }
+
+    const trimmed = branchName.trim()
+
+    // Git branch naming rules
+    const invalidPatterns = [
+        /\.\./, // No double dots
+        /\/$/, // Cannot end with /
+        /^\//, // Cannot start with /
+        /\@\{/, // No @{
+        /\\/, // No backslash
+        /[\x00-\x1f\x7f]/, // No control characters
+        /[\s~^:?*\[]/, // No whitespace or special chars
+    ]
+
+    for (const pattern of invalidPatterns) {
+        if (pattern.test(trimmed)) {
+            throw new Error(`Invalid branch name: "${branchName}" violates Git naming rules`)
+        }
+    }
+
+    if (trimmed.length > 255) {
+        throw new Error('Invalid branch name: too long (max 255 characters)')
+    }
+
+    return trimmed
+}
+
+/**
+ * Validates file path to prevent path traversal attacks
+ */
+function validateFilePath(filePath, allowAbsolute = false) {
+    if (!filePath || typeof filePath !== 'string') {
+        throw new Error('Invalid file path: must be a non-empty string')
+    }
+
+    const normalized = path.normalize(filePath)
+
+    // Prevent path traversal
+    if (normalized.includes('..')) {
+        throw new Error('Invalid file path: path traversal detected')
+    }
+
+    // Check for absolute paths if not allowed
+    if (!allowAbsolute && path.isAbsolute(normalized)) {
+        throw new Error('Invalid file path: absolute paths not allowed')
+    }
+
+    // Prevent null bytes
+    if (normalized.includes('\0')) {
+        throw new Error('Invalid file path: null byte detected')
+    }
+
+    // Check length
+    if (normalized.length > 4096) {
+        throw new Error('Invalid file path: too long (max 4096 characters)')
+    }
+
+    return normalized
+}
+
+/**
+ * Validates commit message
+ */
+function validateCommitMessage(message) {
+    if (!message || typeof message !== 'string') {
+        throw new Error('Invalid commit message: must be a non-empty string')
+    }
+
+    const trimmed = message.trim()
+
+    if (trimmed.length === 0) {
+        throw new Error('Invalid commit message: cannot be empty or whitespace only')
+    }
+
+    if (trimmed.length > 10000) {
+        throw new Error('Invalid commit message: too long (max 10000 characters)')
+    }
+
+    return trimmed
+}
+
+/**
+ * Validates email address format
+ */
+function validateEmail(email) {
+    if (!email || typeof email !== 'string') {
+        throw new Error('Invalid email: must be a non-empty string')
+    }
+
+    const trimmed = email.trim()
+
+    // Basic email validation
+    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+    if (!emailPattern.test(trimmed)) {
+        throw new Error('Invalid email format')
+    }
+
+    if (trimmed.length > 254) {
+        throw new Error('Invalid email: too long (max 254 characters)')
+    }
+
+    return trimmed
+}
+
+/**
+ * Validates URL format
+ */
+function validateUrl(url) {
+    if (!url || typeof url !== 'string') {
+        throw new Error('Invalid URL: must be a non-empty string')
+    }
+
+    try {
+        const parsed = new URL(url)
+
+        // Only allow http and https
+        if (!['http:', 'https:'].includes(parsed.protocol)) {
+            throw new Error('Invalid URL: only HTTP and HTTPS protocols are allowed')
+        }
+
+        return url
+    } catch (err) {
+        throw new Error(`Invalid URL format: ${err.message}`)
+    }
+}
+
+/**
+ * Validates username format
+ */
+function validateUsername(username) {
+    if (!username || typeof username !== 'string') {
+        throw new Error('Invalid username: must be a non-empty string')
+    }
+
+    const trimmed = username.trim()
+
+    // Alphanumeric, hyphens, underscores only
+    const validPattern = /^[a-zA-Z0-9_-]+$/
+    if (!validPattern.test(trimmed)) {
+        throw new Error('Invalid username: only alphanumeric characters, hyphens, and underscores allowed')
+    }
+
+    if (trimmed.length < 3) {
+        throw new Error('Invalid username: too short (min 3 characters)')
+    }
+
+    if (trimmed.length > 39) {
+        throw new Error('Invalid username: too long (max 39 characters)')
+    }
+
+    return trimmed
+}
+
+/**
+ * Validates commit ID (hash) format
+ */
+function validateCommitId(commitId) {
+    if (!commitId || typeof commitId !== 'string') {
+        throw new Error('Invalid commit ID: must be a non-empty string')
+    }
+
+    const trimmed = commitId.trim()
+
+    // Allow HEAD or valid hex hash
+    if (trimmed.toLowerCase() === 'head') {
+        return trimmed.toUpperCase()
+    }
+
+    // SHA-1 hash (40 chars) or short hash (7-40 chars)
+    const hashPattern = /^[a-f0-9]{7,40}$/i
+    if (!hashPattern.test(trimmed)) {
+        throw new Error('Invalid commit ID: must be "HEAD" or a valid commit hash')
+    }
+
+    return trimmed
+}
+
+/**
+ * Validates repository name
+ */
+function validateRepoName(name) {
+    if (!name || typeof name !== 'string') {
+        throw new Error('Invalid repository name: must be a non-empty string')
+    }
+
+    const trimmed = name.trim()
+
+    if (trimmed.length < 1) {
+        throw new Error('Invalid repository name: cannot be empty')
+    }
+
+    if (trimmed.length > 100) {
+        throw new Error('Invalid repository name: too long (max 100 characters)')
+    }
+
+    // Prevent path traversal in repo names
+    if (trimmed.includes('..') || trimmed.includes('/') || trimmed.includes('\\')) {
+        throw new Error('Invalid repository name: cannot contain path separators or ".."')
+    }
+
+    return trimmed
+}
+
+/**
+ * Sanitizes text input for display
+ */
+function sanitizeText(text) {
+    if (typeof text !== 'string') return String(text)
+
+    // Remove control characters except newline and tab
+    return text.replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]/g, '')
+}
+
+module.exports = {
+    validateRepoId,
+    validateBranchName,
+    validateFilePath,
+    validateCommitMessage,
+    validateEmail,
+    validateUrl,
+    validateUsername,
+    validateCommitId,
+    validateRepoName,
+    sanitizeText
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resulgit",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "A powerful CLI tool for version control system operations - clone, commit, push, pull, merge, branch management, and more",
   "main": "resulgit.js",
   "bin": {
@@ -34,7 +34,8 @@
   },
   "files": [
     "resulgit.js",
-    "README.md"
+    "README.md",
+    "lib"
   ],
   "dependencies": {
     "ora": "^5.4.1"
@@ -42,4 +43,4 @@
   "devDependencies": {
     "jest": "^29.7.0"
   }
-}
+}