resulgit 1.0.4 → 1.0.6

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
+}