resulgit 1.0.4 → 1.0.6

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.4",
+  "version": "1.0.6",
   "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"
   }
-}
+}