@andrebuzeli/git-mcp 5.4.8 → 5.4.10

package/dist/tools/git-history.js

@@ -0,0 +1,829 @@
+"use strict";
+/**
+ * Git History Tool
+ *
+ * Comprehensive change tracking tool that records all repository modifications
+ * with detailed timestamps, storing history locally in JSON and syncing to remote providers.
+ *
+ * Operations: log, track, sync, export, auto
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHistoryTool = void 0;
+const git_command_executor_js_1 = require("../utils/git-command-executor.js");
+const parameter_validator_js_1 = require("../utils/parameter-validator.js");
+const operation_error_handler_js_1 = require("../utils/operation-error-handler.js");
+const provider_operation_handler_js_1 = require("../providers/provider-operation-handler.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class GitHistoryTool {
+    gitExecutor;
+    providerHandler;
+    historyPath;
+    configPath;
+    constructor(providerConfig) {
+        this.gitExecutor = new git_command_executor_js_1.GitCommandExecutor();
+        this.historyPath = path.join('.git-history', 'history.json');
+        this.configPath = path.join('.git-history', 'config.json');
+        if (providerConfig) {
+            this.providerHandler = new provider_operation_handler_js_1.ProviderOperationHandler(providerConfig);
+        }
+        this.ensureHistoryDirectory();
+    }
+    /**
+     * Execute git-history operation
+     */
+    async execute(params) {
+        const startTime = Date.now();
+        try {
+            // Validate basic parameters
+            const validation = parameter_validator_js_1.ParameterValidator.validateToolParams('git-history', params);
+            if (!validation.isValid) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Parameter validation failed: ${validation.errors.join(', ')}`, params.action, { validationErrors: validation.errors }, validation.suggestions);
+            }
+            // Validate operation-specific parameters
+            const operationValidation = this.validateOperationParams(params);
+            if (!operationValidation.isValid) {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('VALIDATION_ERROR', `Operation validation failed: ${operationValidation.errors.join(', ')}`, params.action, { validationErrors: operationValidation.errors }, operationValidation.suggestions);
+            }
+            // Route to appropriate handler
+            switch (params.action) {
+                case 'log':
+                    return await this.handleLog(params, startTime);
+                case 'track':
+                    return await this.handleTrack(params, startTime);
+                case 'sync':
+                    return await this.handleSync(params, startTime);
+                case 'export':
+                    return await this.handleExport(params, startTime);
+                case 'auto':
+                    return await this.handleAuto(params, startTime);
+                default:
+                    return operation_error_handler_js_1.OperationErrorHandler.createToolError('UNSUPPORTED_OPERATION', `Unsupported operation: ${params.action}`, params.action, { supportedOperations: ['log', 'track', 'sync', 'export', 'auto'] }, ['Use one of the supported operations: log, track, sync, export, auto']);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('EXECUTION_ERROR', `Failed to execute git-history operation: ${errorMessage}`, params.action, { error: errorMessage });
+        }
+    }
+    /**
+     * Validate operation-specific parameters
+     */
+    validateOperationParams(params) {
+        const errors = [];
+        const suggestions = [];
+        switch (params.action) {
+            case 'track':
+                if (!params.message) {
+                    errors.push('Message is required for track operation');
+                    suggestions.push('Provide a message describing the change');
+                }
+                break;
+            case 'sync':
+                if (!this.providerHandler && params.syncMethod === 'api') {
+                    errors.push('Provider configuration required for API sync');
+                    suggestions.push('Configure GitHub/Gitea provider or use file sync method');
+                }
+                break;
+            case 'export':
+                if (params.outputPath && !path.isAbsolute(params.outputPath)) {
+                    errors.push('Output path must be absolute');
+                    suggestions.push('Provide an absolute path for export file');
+                }
+                break;
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            suggestions
+        };
+    }
+    /**
+     * Handle log operation - View history entries
+     */
+    async handleLog(params, startTime) {
+        try {
+            const history = await this.loadHistory();
+            let entries = [...history.entries];
+            // Apply filters
+            if (params.since) {
+                const sinceDate = new Date(params.since);
+                entries = entries.filter(entry => new Date(entry.timestamp) >= sinceDate);
+            }
+            if (params.until) {
+                const untilDate = new Date(params.until);
+                entries = entries.filter(entry => new Date(entry.timestamp) <= untilDate);
+            }
+            if (params.author) {
+                entries = entries.filter(entry => entry.author.toLowerCase().includes(params.author.toLowerCase()) ||
+                    entry.authorEmail.toLowerCase().includes(params.author.toLowerCase()));
+            }
+            if (params.filePath) {
+                entries = entries.filter(entry => entry.filesChanged.some(file => file.path.includes(params.filePath)));
+            }
+            if (params.branch) {
+                entries = entries.filter(entry => entry.branch === params.branch);
+            }
+            // Sort by timestamp (newest first)
+            entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+            // Apply limit
+            const limit = params.limit || 50;
+            entries = entries.slice(0, limit);
+            // Format output
+            const format = params.format || 'json';
+            let formattedData;
+            if (format === 'markdown') {
+                formattedData = this.formatHistoryAsMarkdown(entries);
+            }
+            else {
+                formattedData = {
+                    totalEntries: history.entries.length,
+                    filteredEntries: entries.length,
+                    entries: entries
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    ...formattedData,
+                    filters: {
+                        since: params.since,
+                        until: params.until,
+                        author: params.author,
+                        filePath: params.filePath,
+                        branch: params.branch,
+                        limit: limit
+                    }
+                },
+                metadata: {
+                    operation: params.action,
+                    executionTime: Date.now() - startTime,
+                    timestamp: new Date().toISOString()
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('LOG_FAILED', `Failed to retrieve history: ${errorMessage}`, params.action, { error: errorMessage });
+        }
+    }
+    /**
+     * Handle track operation - Manually record a change
+     */
+    async handleTrack(params, startTime) {
+        try {
+            const currentBranch = await this.getCurrentBranch(params.projectPath);
+            const timestamp = params.timestamp || new Date().toISOString();
+            const entry = {
+                id: `manual-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                timestamp,
+                author: await this.getProviderUserName() || 'Unknown',
+                authorEmail: await this.getGitUserEmail() || '',
+                message: params.message,
+                filesChanged: params.files ? params.files.map(file => ({
+                    path: file,
+                    status: 'modified',
+                    additions: params.additions || 0,
+                    deletions: params.deletions || 0
+                })) : [],
+                additions: params.additions || 0,
+                deletions: params.deletions || 0,
+                branch: currentBranch || 'main',
+                manual: true,
+                synced: false
+            };
+            await this.addHistoryEntry(entry);
+            return {
+                success: true,
+                data: {
+                    entry: entry,
+                    message: 'Change tracked successfully'
+                },
+                metadata: {
+                    operation: params.action,
+                    executionTime: Date.now() - startTime,
+                    timestamp: new Date().toISOString()
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('TRACK_FAILED', `Failed to track change: ${errorMessage}`, params.action, { error: errorMessage });
+        }
+    }
+    /**
+     * Handle sync operation - Sync local history to remote
+     */
+    async handleSync(params, startTime) {
+        try {
+            const history = await this.loadHistory();
+            const unsyncedEntries = history.entries.filter(entry => !entry.synced);
+            if (unsyncedEntries.length === 0) {
+                return {
+                    success: true,
+                    data: {
+                        message: 'All entries are already synced',
+                        totalEntries: history.entries.length,
+                        syncedEntries: history.entries.length - unsyncedEntries.length,
+                        unsyncedEntries: 0
+                    },
+                    metadata: {
+                        operation: params.action,
+                        executionTime: Date.now() - startTime,
+                        timestamp: new Date().toISOString()
+                    }
+                };
+            }
+            const syncMethod = params.syncMethod || 'file';
+            let syncResult = {};
+            if (syncMethod === 'file') {
+                syncResult = await this.syncViaFile(params, unsyncedEntries);
+            }
+            else if (syncMethod === 'api') {
+                syncResult = await this.syncViaApi(params, unsyncedEntries);
+            }
+            else {
+                return operation_error_handler_js_1.OperationErrorHandler.createToolError('INVALID_SYNC_METHOD', `Invalid sync method: ${syncMethod}`, params.action, { supportedMethods: ['file', 'api'] }, ['Use "file" to commit history.json or "api" to use provider API']);
+            }
+            // Mark entries as synced
+            const updatedHistory = await this.loadHistory();
+            updatedHistory.entries.forEach(entry => {
+                if (!entry.synced && unsyncedEntries.some(u => u.id === entry.id)) {
+                    entry.synced = true;
+                }
+            });
+            await this.saveHistory(updatedHistory);
+            return {
+                success: true,
+                data: {
+                    ...syncResult,
+                    syncedEntries: unsyncedEntries.length,
+                    totalEntries: history.entries.length,
+                    syncMethod
+                },
+                metadata: {
+                    operation: params.action,
+                    executionTime: Date.now() - startTime,
+                    timestamp: new Date().toISOString()
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('SYNC_FAILED', `Failed to sync history: ${errorMessage}`, params.action, { error: errorMessage });
+        }
+    }
+    /**
+     * Handle export operation - Export history to file
+     */
+    async handleExport(params, startTime) {
+        try {
+            const history = await this.loadHistory();
+            const outputPath = params.outputPath || path.join(params.projectPath, 'HISTORY.json');
+            let exportData;
+            if (path.extname(outputPath).toLowerCase() === '.md') {
+                // Export as Markdown
+                exportData = this.formatHistoryAsMarkdown(history.entries);
+            }
+            else {
+                // Export as JSON
+                exportData = {
+                    exportedAt: new Date().toISOString(),
+                    totalEntries: history.entries.length,
+                    includeDiffs: params.includeDiffs || false,
+                    entries: params.includeDiffs ? history.entries : history.entries.map(entry => {
+                        const { diff, ...entryWithoutDiff } = entry;
+                        return entryWithoutDiff;
+                    })
+                };
+            }
+            // Write to file
+            const outputDir = path.dirname(outputPath);
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            if (typeof exportData === 'string') {
+                fs.writeFileSync(outputPath, exportData, 'utf8');
+            }
+            else {
+                fs.writeFileSync(outputPath, JSON.stringify(exportData, null, 2), 'utf8');
+            }
+            return {
+                success: true,
+                data: {
+                    exportedPath: outputPath,
+                    format: path.extname(outputPath).toLowerCase() === '.md' ? 'markdown' : 'json',
+                    totalEntries: history.entries.length,
+                    includeDiffs: params.includeDiffs || false
+                },
+                metadata: {
+                    operation: params.action,
+                    executionTime: Date.now() - startTime,
+                    timestamp: new Date().toISOString()
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('EXPORT_FAILED', `Failed to export history: ${errorMessage}`, params.action, { error: errorMessage });
+        }
+    }
+    /**
+     * Handle auto operation - Enable/disable automatic tracking
+     */
+    async handleAuto(params, startTime) {
+        try {
+            const config = await this.loadConfig();
+            const wasEnabled = config.autoTracking;
+            if (params.enabled !== undefined) {
+                config.autoTracking = params.enabled;
+                await this.saveConfig(config);
+                if (params.enabled && !wasEnabled) {
+                    // Enable auto-tracking - sync current commits
+                    await this.syncRecentCommits();
+                }
+            }
+            return {
+                success: true,
+                data: {
+                    autoTrackingEnabled: config.autoTracking,
+                    message: `Auto-tracking ${config.autoTracking ? 'enabled' : 'disabled'}`
+                },
+                metadata: {
+                    operation: params.action,
+                    executionTime: Date.now() - startTime,
+                    timestamp: new Date().toISOString()
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return operation_error_handler_js_1.OperationErrorHandler.createToolError('AUTO_CONFIG_FAILED', `Failed to configure auto-tracking: ${errorMessage}`, params.action, { error: errorMessage });
+        }
+    }
+    /**
+     * Sync via file commit
+     */
+    async syncViaFile(params, entries) {
+        try {
+            const historyFile = path.join(params.projectPath, 'HISTORY.json');
+            // Write history to repository
+            const historyData = {
+                lastUpdated: new Date().toISOString(),
+                entries: entries
+            };
+            fs.writeFileSync(historyFile, JSON.stringify(historyData, null, 2), 'utf8');
+            // Commit the file
+            const addResult = await this.gitExecutor.executeGitCommand('add', ['HISTORY.json'], params.projectPath);
+            if (!addResult.success) {
+                throw new Error(`Failed to add HISTORY.json: ${addResult.stderr}`);
+            }
+            const commitResult = await this.gitExecutor.executeGitCommand('commit', ['-m', `Update history: ${entries.length} new entries`], params.projectPath);
+            if (!commitResult.success && !commitResult.stderr.includes('nothing to commit')) {
+                throw new Error(`Failed to commit HISTORY.json: ${commitResult.stderr}`);
+            }
+            return {
+                method: 'file',
+                committed: commitResult.success,
+                message: 'History synced via file commit'
+            };
+        }
+        catch (error) {
+            throw new Error(`File sync failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Sync via provider API
+     */
+    async syncViaApi(params, entries) {
+        if (!this.providerHandler) {
+            throw new Error('Provider handler not configured');
+        }
+        try {
+            const provider = params.provider || 'github';
+            const repo = params.repo || await this.getRepoName();
+            // Create a summary entry for the API
+            const summary = {
+                period: `${entries[0]?.timestamp} to ${entries[entries.length - 1]?.timestamp}`,
+                totalEntries: entries.length,
+                authors: [...new Set(entries.map(e => e.author))],
+                filesChanged: entries.reduce((sum, e) => sum + e.filesChanged.length, 0),
+                totalAdditions: entries.reduce((sum, e) => sum + e.additions, 0),
+                totalDeletions: entries.reduce((sum, e) => sum + e.deletions, 0),
+                entries: entries.slice(0, 10) // Include first 10 entries in detail
+            };
+            const operation = {
+                provider,
+                operation: 'create',
+                parameters: {
+                    repo,
+                    title: `History Update: ${entries.length} changes`,
+                    body: JSON.stringify(summary, null, 2),
+                    type: 'issue' // Create as issue for tracking
+                },
+                requiresAuth: true,
+                isRemoteOperation: true
+            };
+            const result = await this.providerHandler.executeOperation(operation);
+            return {
+                method: 'api',
+                provider,
+                success: result.success,
+                message: result.success ? 'History synced via API' : 'API sync failed'
+            };
+        }
+        catch (error) {
+            throw new Error(`API sync failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Format history as Markdown
+     */
+    formatHistoryAsMarkdown(entries) {
+        let markdown = '# Repository History\n\n';
+        markdown += `Generated on: ${new Date().toISOString()}\n\n`;
+        markdown += `Total entries: ${entries.length}\n\n`;
+        for (const entry of entries) {
+            markdown += `## ${entry.message}\n\n`;
+            markdown += `- **Date:** ${new Date(entry.timestamp).toLocaleString()}\n`;
+            markdown += `- **Author:** ${entry.author} <${entry.authorEmail}>\n`;
+            markdown += `- **Branch:** ${entry.branch}\n`;
+            markdown += `- **Commit:** ${entry.commitHash || 'Manual entry'}\n`;
+            markdown += `- **Changes:** +${entry.additions} -${entry.deletions}\n`;
+            if (entry.filesChanged.length > 0) {
+                markdown += `- **Files changed:**\n`;
+                for (const file of entry.filesChanged) {
+                    markdown += `  - ${file.status.toUpperCase()}: ${file.path} (+${file.additions} -${file.deletions})\n`;
+                }
+            }
+            if (entry.tags && entry.tags.length > 0) {
+                markdown += `- **Tags:** ${entry.tags.join(', ')}\n`;
+            }
+            markdown += '\n---\n\n';
+        }
+        return markdown;
+    }
+    /**
+     * Load history from file
+     */
+    async loadHistory() {
+        try {
+            if (fs.existsSync(this.historyPath)) {
+                const data = fs.readFileSync(this.historyPath, 'utf8');
+                return JSON.parse(data);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load history file:', error);
+        }
+        return { entries: [] };
+    }
+    /**
+     * Save history to file
+     */
+    async saveHistory(history) {
+        try {
+            fs.writeFileSync(this.historyPath, JSON.stringify(history, null, 2), 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to save history: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Add entry to history
+     */
+    async addHistoryEntry(entry) {
+        const history = await this.loadHistory();
+        history.entries.push(entry);
+        await this.saveHistory(history);
+    }
+    /**
+     * Load configuration
+     */
+    async loadConfig() {
+        try {
+            if (fs.existsSync(this.configPath)) {
+                const data = fs.readFileSync(this.configPath, 'utf8');
+                return JSON.parse(data);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load config file:', error);
+        }
+        return { autoTracking: false };
+    }
+    /**
+     * Save configuration
+     */
+    async saveConfig(config) {
+        try {
+            fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2), 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to save config: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Sync recent commits to history
+     */
+    async syncRecentCommits() {
+        try {
+            const config = await this.loadConfig();
+            const lastHash = config.lastCommitHash;
+            // Get commits since last sync
+            const logArgs = ['--oneline', '--numstat', '--format=format:%H|%an|%ae|%ad|%s'];
+            if (lastHash) {
+                logArgs.push(`${lastHash}..HEAD`);
+            }
+            const logResult = await this.gitExecutor.executeGitCommand('log', logArgs);
+            if (!logResult.success) {
+                console.warn('Failed to get git log:', logResult.stderr);
+                return;
+            }
+            const lines = logResult.stdout.split('\n').filter(line => line.trim());
+            let currentEntry = null;
+            for (const line of lines) {
+                if (line.includes('|')) {
+                    // Commit header line
+                    if (currentEntry) {
+                        await this.addHistoryEntry(currentEntry);
+                    }
+                    const [hash, gitAuthor, email, date, ...messageParts] = line.split('|');
+                    const message = messageParts.join('|');
+                    currentEntry = {
+                        id: `commit-${hash}`,
+                        timestamp: new Date(date).toISOString(),
+                        commitHash: hash,
+                        author: await this.getProviderUserName() || gitAuthor, // Use provider username, fallback to git author
+                        authorEmail: email,
+                        message,
+                        filesChanged: [],
+                        additions: 0,
+                        deletions: 0,
+                        branch: await this.getCurrentBranch() || 'main',
+                        synced: false
+                    };
+                }
+                else if (line.trim() && currentEntry) {
+                    // File change line (from --numstat)
+                    const parts = line.trim().split('\t');
+                    if (parts.length >= 3) {
+                        const additions = parseInt(parts[0]) || 0;
+                        const deletions = parseInt(parts[1]) || 0;
+                        const filePath = parts[2];
+                        currentEntry.filesChanged.push({
+                            path: filePath,
+                            status: additions === 0 && deletions === 0 ? 'modified' : (additions > 0 ? 'added' : 'deleted'),
+                            additions,
+                            deletions
+                        });
+                        currentEntry.additions += additions;
+                        currentEntry.deletions += deletions;
+                    }
+                }
+            }
+            // Add the last entry
+            if (currentEntry) {
+                await this.addHistoryEntry(currentEntry);
+            }
+            // Update last commit hash
+            const latestHash = await this.getLatestCommitHash();
+            if (latestHash) {
+                config.lastCommitHash = latestHash;
+                config.lastSyncTimestamp = new Date().toISOString();
+                await this.saveConfig(config);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to sync recent commits:', error);
+        }
+    }
+    /**
+     * Get current branch
+     */
+    async getCurrentBranch(projectPath) {
+        try {
+            const result = await this.gitExecutor.executeGitCommand('branch', ['--show-current'], projectPath);
+            return result.success ? result.stdout.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get provider username (GitHub or Gitea username from env)
+     */
+    async getProviderUserName() {
+        // Try GitHub username first
+        const githubUser = process.env.GITHUB_USERNAME;
+        if (githubUser)
+            return githubUser;
+        // Try Gitea username
+        const giteaUser = process.env.GITEA_USERNAME;
+        if (giteaUser)
+            return giteaUser;
+        // Fallback to git config user name
+        try {
+            const result = await this.gitExecutor.executeGitCommand('config', ['user.name']);
+            return result.success ? result.stdout.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get git user email
+     */
+    async getGitUserEmail() {
+        try {
+            const result = await this.gitExecutor.executeGitCommand('config', ['user.email']);
+            return result.success ? result.stdout.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get latest commit hash
+     */
+    async getLatestCommitHash() {
+        try {
+            const result = await this.gitExecutor.executeGitCommand('rev-parse', ['HEAD']);
+            return result.success ? result.stdout.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get repository name from git config
+     */
+    async getRepoName() {
+        try {
+            const result = await this.gitExecutor.executeGitCommand('config', ['--get', 'remote.origin.url']);
+            if (result.success) {
+                const url = result.stdout.trim();
+                // Extract repo name from URL (supports GitHub and Gitea formats)
+                const match = url.match(/\/([^\/]+?)(?:\.git)?$/);
+                return match ? match[1] : null;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return null;
+    }
+    /**
+     * Ensure history directory exists
+     */
+    ensureHistoryDirectory() {
+        try {
+            const dir = path.dirname(this.historyPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+        catch (error) {
+            console.warn('Failed to create history directory:', error);
+        }
+    }
+    /**
+     * Get tool schema for MCP registration
+     */
+    static getToolSchema() {
+        return {
+            name: 'git-history',
+            description: 'Comprehensive change tracking tool that records all repository modifications with detailed timestamps, storing history locally in JSON and syncing to remote providers.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['log', 'track', 'sync', 'export', 'auto'],
+                        description: 'The git-history operation to perform'
+                    },
+                    projectPath: {
+                        type: 'string',
+                        description: 'Absolute path to the project directory'
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Number of entries to show (default: 50)',
+                        minimum: 1,
+                        maximum: 1000
+                    },
+                    since: {
+                        type: 'string',
+                        description: 'Start date filter (ISO 8601 format)'
+                    },
+                    until: {
+                        type: 'string',
+                        description: 'End date filter (ISO 8601 format)'
+                    },
+                    author: {
+                        type: 'string',
+                        description: 'Filter by author name or email'
+                    },
+                    filePath: {
+                        type: 'string',
+                        description: 'Filter by file path'
+                    },
+                    branch: {
+                        type: 'string',
+                        description: 'Filter by branch name'
+                    },
+                    format: {
+                        type: 'string',
+                        enum: ['json', 'markdown'],
+                        description: 'Output format for log operation'
+                    },
+                    message: {
+                        type: 'string',
+                        description: 'Change description (required for track operation)'
+                    },
+                    timestamp: {
+                        type: 'string',
+                        description: 'Custom timestamp for track operation (ISO 8601 format)'
+                    },
+                    files: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Files affected by the change (for track operation)'
+                    },
+                    additions: {
+                        type: 'number',
+                        description: 'Lines added (for track operation)',
+                        minimum: 0
+                    },
+                    deletions: {
+                        type: 'number',
+                        description: 'Lines deleted (for track operation)',
+                        minimum: 0
+                    },
+                    provider: {
+                        type: 'string',
+                        enum: ['github', 'gitea', 'both'],
+                        description: 'Provider for remote sync operations'
+                    },
+                    syncMethod: {
+                        type: 'string',
+                        enum: ['file', 'api'],
+                        description: 'Sync method: file (commit to repo) or api (use provider API)'
+                    },
+                    repo: {
+                        type: 'string',
+                        description: 'Repository name for remote sync'
+                    },
+                    outputPath: {
+                        type: 'string',
+                        description: 'Export file path (absolute path required)'
+                    },
+                    includeDiffs: {
+                        type: 'boolean',
+                        description: 'Include full diffs in export (default: false)'
+                    },
+                    enabled: {
+                        type: 'boolean',
+                        description: 'Enable/disable auto-tracking (for auto operation)'
+                    }
+                },
+                required: ['action', 'projectPath']
+            }
+        };
+    }
+}
+exports.GitHistoryTool = GitHistoryTool;
+//# sourceMappingURL=git-history.js.map