Datasets:

chahuadev
/

Chahuadev-smart-roadmap

/**
 * Git Context Analyzer
 * Zero-dependency Git integration using child_process
 * 
 * Extracts business context and history from Git:
 * - Task age from git blame
 * - Commit messages and types (feat:, fix:, BREAKING CHANGE:)
 * - Author information
 * - Change frequency
 */

const { execSync } = require('child_process');
const path = require('path');

class GitContextAnalyzer {
    constructor(projectRoot) {
        this.projectRoot = projectRoot;
        this.isGitRepo = this.checkGitRepository();
    }

    /**
     * Check if project is a Git repository
     */
    checkGitRepository() {
        try {
            execSync('git rev-parse --git-dir', {
                cwd: this.projectRoot,
                stdio: 'ignore'
            });
            return true;
        } catch (error) {
            return false;
        }
    }

    /**
     * Get blame information for specific line
     * Returns actual date when TODO/FIXME was written
     */
    getBlameForLine(filePath, lineNumber) {
        if (!this.isGitRepo) return null;

        try {
            const relativePath = path.relative(this.projectRoot, filePath);
            const output = execSync(
                `git blame -L ${lineNumber},${lineNumber} --porcelain "${relativePath}"`,
                {
                    cwd: this.projectRoot,
                    encoding: 'utf8',
                    timeout: 5000
                }
            );

            return this.parseBlameOutput(output);
        } catch (error) {
            return null;
        }
    }

    /**
     * Parse git blame porcelain output
     */
    parseBlameOutput(output) {
        const lines = output.split('\n');
        const result = {
            commit: null,
            author: null,
            authorMail: null,
            authorTime: null,
            authorTz: null,
            committer: null,
            committerTime: null,
            summary: null,
            filename: null
        };

        for (const line of lines) {
            if (line.startsWith('author ')) {
                result.author = line.substring(7).trim();
            } else if (line.startsWith('author-mail ')) {
                result.authorMail = line.substring(12).trim().replace(/[<>]/g, '');
            } else if (line.startsWith('author-time ')) {
                const timestamp = parseInt(line.substring(12).trim());
                result.authorTime = new Date(timestamp * 1000);
            } else if (line.startsWith('author-tz ')) {
                result.authorTz = line.substring(10).trim();
            } else if (line.startsWith('committer ')) {
                result.committer = line.substring(10).trim();
            } else if (line.startsWith('committer-time ')) {
                const timestamp = parseInt(line.substring(15).trim());
                result.committerTime = new Date(timestamp * 1000);
            } else if (line.startsWith('summary ')) {
                result.summary = line.substring(8).trim();
            } else if (line.startsWith('filename ')) {
                result.filename = line.substring(9).trim();
            } else if (/^[0-9a-f]{40}/.test(line)) {
                result.commit = line.split(' ')[0];
            }
        }

        return result;
    }

    /**
     * Get commit history for file
     */
    getFileHistory(filePath, limit = 50) {
        if (!this.isGitRepo) return [];

        try {
            const relativePath = path.relative(this.projectRoot, filePath);
            const output = execSync(
                `git log --pretty=format:"%H|%an|%ae|%at|%s" -n ${limit} -- "${relativePath}"`,
                {
                    cwd: this.projectRoot,
                    encoding: 'utf8',
                    timeout: 10000
                }
            );

            return this.parseLogOutput(output);
        } catch (error) {
            return [];
        }
    }

    /**
     * Parse git log output
     */
    parseLogOutput(output) {
        if (!output) return [];

        const lines = output.split('\n');
        const commits = [];

        for (const line of lines) {
            if (!line) continue;

            const [hash, author, email, timestamp, ...messageParts] = line.split('|');
            const message = messageParts.join('|');

            commits.push({
                hash,
                author,
                email,
                date: new Date(parseInt(timestamp) * 1000),
                message,
                type: this.detectCommitType(message),
                isBreaking: this.isBreakingChange(message)
            });
        }

        return commits;
    }

    /**
     * Detect commit type from Conventional Commits
     */
    detectCommitType(message) {
        const lowerMessage = message.toLowerCase();

        if (lowerMessage.startsWith('feat:') || lowerMessage.startsWith('feat(')) {
            return 'feat';
        } else if (lowerMessage.startsWith('fix:') || lowerMessage.startsWith('fix(')) {
            return 'fix';
        } else if (lowerMessage.startsWith('docs:') || lowerMessage.startsWith('docs(')) {
            return 'docs';
        } else if (lowerMessage.startsWith('style:') || lowerMessage.startsWith('style(')) {
            return 'style';
        } else if (lowerMessage.startsWith('refactor:') || lowerMessage.startsWith('refactor(')) {
            return 'refactor';
        } else if (lowerMessage.startsWith('perf:') || lowerMessage.startsWith('perf(')) {
            return 'perf';
        } else if (lowerMessage.startsWith('test:') || lowerMessage.startsWith('test(')) {
            return 'test';
        } else if (lowerMessage.startsWith('build:') || lowerMessage.startsWith('build(')) {
            return 'build';
        } else if (lowerMessage.startsWith('ci:') || lowerMessage.startsWith('ci(')) {
            return 'ci';
        } else if (lowerMessage.startsWith('chore:') || lowerMessage.startsWith('chore(')) {
            return 'chore';
        }

        return 'other';
    }

    /**
     * Check if commit is breaking change
     */
    isBreakingChange(message) {
        return message.toUpperCase().includes('BREAKING CHANGE:') ||
               message.toUpperCase().includes('BREAKING-CHANGE:') ||
               message.includes('!:');
    }

    /**
     * Calculate actual age of annotation (TODO/FIXME)
     */
    getAnnotationAge(filePath, lineNumber) {
        const blame = this.getBlameForLine(filePath, lineNumber);
        if (!blame || !blame.authorTime) return null;

        const now = new Date();
        const ageMs = now - blame.authorTime;
        const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));

        return {
            days: ageDays,
            author: blame.author,
            authorMail: blame.authorMail,
            date: blame.authorTime,
            commit: blame.commit,
            summary: blame.summary
        };
    }

    /**
     * Get change frequency for file (how often it's modified)
     */
    getChangeFrequency(filePath) {
        const history = this.getFileHistory(filePath);
        if (history.length === 0) return null;

        const firstCommit = history[history.length - 1].date;
        const lastCommit = history[0].date;
        const ageMs = lastCommit - firstCommit;
        const ageDays = Math.max(1, ageMs / (1000 * 60 * 60 * 24));

        return {
            totalCommits: history.length,
            changesPerWeek: (history.length / ageDays) * 7,
            firstCommit,
            lastCommit,
            ageDays: Math.floor(ageDays),
            isActive: ageDays < 90 // Active if modified in last 3 months
        };
    }

    /**
     * Enrich task with Git context
     */
    enrichTask(task) {
        if (!this.isGitRepo || !task.filePath || !task.line) {
            return task;
        }

        const fullPath = path.join(this.projectRoot, task.filePath);
        
        // Get annotation age
        const age = this.getAnnotationAge(fullPath, task.line);
        if (age) {
            task.actualAge = age.days;
            task.author = age.author;
            task.authorMail = age.authorMail;
            task.createdDate = age.date;
            task.createdCommit = age.commit;
        }

        // Get file history
        const frequency = this.getChangeFrequency(fullPath);
        if (frequency) {
            task.fileCommits = frequency.totalCommits;
            task.fileChangesPerWeek = frequency.changesPerWeek;
            task.fileIsActive = frequency.isActive;
            task.fileAgeDays = frequency.ageDays;
        }

        // Get recent commits for context
        const history = this.getFileHistory(fullPath, 10);
        if (history.length > 0) {
            task.recentCommits = history.slice(0, 5).map(c => ({
                message: c.message,
                type: c.type,
                isBreaking: c.isBreaking,
                author: c.author,
                date: c.date
            }));

            // Check if file has breaking changes
            task.hasBreakingChanges = history.some(c => c.isBreaking);
            
            // Check if file is feature-heavy
            const featureCommits = history.filter(c => c.type === 'feat').length;
            task.isFeatureFile = featureCommits > history.length * 0.3;
        }

        return task;
    }

    /**
     * Analyze entire project history
     */
    analyzeProjectHistory() {
        if (!this.isGitRepo) return null;

        try {
            // Get all commits
            const output = execSync(
                'git log --pretty=format:"%H|%an|%ae|%at|%s" --all',
                {
                    cwd: this.projectRoot,
                    encoding: 'utf8',
                    timeout: 30000,
                    maxBuffer: 10 * 1024 * 1024 // 10MB buffer
                }
            );

            const commits = this.parseLogOutput(output);

            // Statistics
            const typeCount = {};
            let breakingChanges = 0;
            const authors = new Set();

            for (const commit of commits) {
                typeCount[commit.type] = (typeCount[commit.type] || 0) + 1;
                if (commit.isBreaking) breakingChanges++;
                authors.add(commit.author);
            }

            return {
                totalCommits: commits.length,
                totalAuthors: authors.size,
                breakingChanges,
                typeDistribution: typeCount,
                firstCommit: commits[commits.length - 1]?.date,
                lastCommit: commits[0]?.date,
                commits: commits.slice(0, 100) // Keep last 100
            };
        } catch (error) {
            return null;
        }
    }

    /**
     * Get contributors statistics
     */
    getContributors() {
        if (!this.isGitRepo) return [];

        try {
            const output = execSync(
                'git shortlog -sn --all --no-merges',
                {
                    cwd: this.projectRoot,
                    encoding: 'utf8',
                    timeout: 10000
                }
            );

            const lines = output.trim().split('\n');
            return lines.map(line => {
                const match = line.trim().match(/^(\d+)\s+(.+)$/);
                if (match) {
                    return {
                        commits: parseInt(match[1]),
                        name: match[2]
                    };
                }
                return null;
            }).filter(Boolean);
        } catch (error) {
            return [];
        }
    }
}

module.exports = GitContextAnalyzer;

	/**
	* Git Context Analyzer
	* Zero-dependency Git integration using child_process
	*
	* Extracts business context and history from Git:
	* - Task age from git blame
	* - Commit messages and types (feat:, fix:, BREAKING CHANGE:)
	* - Author information
	* - Change frequency
	*/

	const { execSync } = require('child_process');
	const path = require('path');

	class GitContextAnalyzer {
	constructor(projectRoot) {
	this.projectRoot = projectRoot;
	this.isGitRepo = this.checkGitRepository();
	}

	/**
	* Check if project is a Git repository
	*/
	checkGitRepository() {
	try {
	execSync('git rev-parse --git-dir', {
	cwd: this.projectRoot,
	stdio: 'ignore'
	});
	return true;
	} catch (error) {
	return false;
	}
	}

	/**
	* Get blame information for specific line
	* Returns actual date when TODO/FIXME was written
	*/
	getBlameForLine(filePath, lineNumber) {
	if (!this.isGitRepo) return null;

	try {
	const relativePath = path.relative(this.projectRoot, filePath);
	const output = execSync(
	`git blame -L ${lineNumber},${lineNumber} --porcelain "${relativePath}"`,
	{
	cwd: this.projectRoot,
	encoding: 'utf8',
	timeout: 5000
	}
	);

	return this.parseBlameOutput(output);
	} catch (error) {
	return null;
	}
	}

	/**
	* Parse git blame porcelain output
	*/
	parseBlameOutput(output) {
	const lines = output.split('\n');
	const result = {
	commit: null,
	author: null,
	authorMail: null,
	authorTime: null,
	authorTz: null,
	committer: null,
	committerTime: null,
	summary: null,
	filename: null
	};

	for (const line of lines) {
	if (line.startsWith('author ')) {
	result.author = line.substring(7).trim();
	} else if (line.startsWith('author-mail ')) {
	result.authorMail = line.substring(12).trim().replace(/[<>]/g, '');
	} else if (line.startsWith('author-time ')) {
	const timestamp = parseInt(line.substring(12).trim());
	result.authorTime = new Date(timestamp * 1000);
	} else if (line.startsWith('author-tz ')) {
	result.authorTz = line.substring(10).trim();
	} else if (line.startsWith('committer ')) {
	result.committer = line.substring(10).trim();
	} else if (line.startsWith('committer-time ')) {
	const timestamp = parseInt(line.substring(15).trim());
	result.committerTime = new Date(timestamp * 1000);
	} else if (line.startsWith('summary ')) {
	result.summary = line.substring(8).trim();
	} else if (line.startsWith('filename ')) {
	result.filename = line.substring(9).trim();
	} else if (/^[0-9a-f]{40}/.test(line)) {
	result.commit = line.split(' ')[0];
	}
	}

	return result;
	}

	/**
	* Get commit history for file
	*/
	getFileHistory(filePath, limit = 50) {
	if (!this.isGitRepo) return [];

	try {
	const relativePath = path.relative(this.projectRoot, filePath);
	const output = execSync(
	`git log --pretty=format:"%H\|%an\|%ae\|%at\|%s" -n ${limit} -- "${relativePath}"`,
	{
	cwd: this.projectRoot,
	encoding: 'utf8',
	timeout: 10000
	}
	);

	return this.parseLogOutput(output);
	} catch (error) {
	return [];
	}
	}

	/**
	* Parse git log output
	*/
	parseLogOutput(output) {
	if (!output) return [];

	const lines = output.split('\n');
	const commits = [];

	for (const line of lines) {
	if (!line) continue;

	const [hash, author, email, timestamp, ...messageParts] = line.split('\|');
	const message = messageParts.join('\|');

	commits.push({
	hash,
	author,
	email,
	date: new Date(parseInt(timestamp) * 1000),
	message,
	type: this.detectCommitType(message),
	isBreaking: this.isBreakingChange(message)
	});
	}

	return commits;
	}

	/**
	* Detect commit type from Conventional Commits
	*/
	detectCommitType(message) {
	const lowerMessage = message.toLowerCase();

	if (lowerMessage.startsWith('feat:') \|\| lowerMessage.startsWith('feat(')) {
	return 'feat';
	} else if (lowerMessage.startsWith('fix:') \|\| lowerMessage.startsWith('fix(')) {
	return 'fix';
	} else if (lowerMessage.startsWith('docs:') \|\| lowerMessage.startsWith('docs(')) {
	return 'docs';
	} else if (lowerMessage.startsWith('style:') \|\| lowerMessage.startsWith('style(')) {
	return 'style';
	} else if (lowerMessage.startsWith('refactor:') \|\| lowerMessage.startsWith('refactor(')) {
	return 'refactor';
	} else if (lowerMessage.startsWith('perf:') \|\| lowerMessage.startsWith('perf(')) {
	return 'perf';
	} else if (lowerMessage.startsWith('test:') \|\| lowerMessage.startsWith('test(')) {
	return 'test';
	} else if (lowerMessage.startsWith('build:') \|\| lowerMessage.startsWith('build(')) {
	return 'build';
	} else if (lowerMessage.startsWith('ci:') \|\| lowerMessage.startsWith('ci(')) {
	return 'ci';
	} else if (lowerMessage.startsWith('chore:') \|\| lowerMessage.startsWith('chore(')) {
	return 'chore';
	}

	return 'other';
	}

	/**
	* Check if commit is breaking change
	*/
	isBreakingChange(message) {
	return message.toUpperCase().includes('BREAKING CHANGE:') \|\|
	message.toUpperCase().includes('BREAKING-CHANGE:') \|\|
	message.includes('!:');
	}

	/**
	* Calculate actual age of annotation (TODO/FIXME)
	*/
	getAnnotationAge(filePath, lineNumber) {
	const blame = this.getBlameForLine(filePath, lineNumber);
	if (!blame \|\| !blame.authorTime) return null;

	const now = new Date();
	const ageMs = now - blame.authorTime;
	const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));

	return {
	days: ageDays,
	author: blame.author,
	authorMail: blame.authorMail,
	date: blame.authorTime,
	commit: blame.commit,
	summary: blame.summary
	};
	}

	/**
	* Get change frequency for file (how often it's modified)
	*/
	getChangeFrequency(filePath) {
	const history = this.getFileHistory(filePath);
	if (history.length === 0) return null;

	const firstCommit = history[history.length - 1].date;
	const lastCommit = history[0].date;
	const ageMs = lastCommit - firstCommit;
	const ageDays = Math.max(1, ageMs / (1000 * 60 * 60 * 24));

	return {
	totalCommits: history.length,
	changesPerWeek: (history.length / ageDays) * 7,
	firstCommit,
	lastCommit,
	ageDays: Math.floor(ageDays),
	isActive: ageDays < 90 // Active if modified in last 3 months
	};
	}

	/**
	* Enrich task with Git context
	*/
	enrichTask(task) {
	if (!this.isGitRepo \|\| !task.filePath \|\| !task.line) {
	return task;
	}

	const fullPath = path.join(this.projectRoot, task.filePath);

	// Get annotation age
	const age = this.getAnnotationAge(fullPath, task.line);
	if (age) {
	task.actualAge = age.days;
	task.author = age.author;
	task.authorMail = age.authorMail;
	task.createdDate = age.date;
	task.createdCommit = age.commit;
	}

	// Get file history
	const frequency = this.getChangeFrequency(fullPath);
	if (frequency) {
	task.fileCommits = frequency.totalCommits;
	task.fileChangesPerWeek = frequency.changesPerWeek;
	task.fileIsActive = frequency.isActive;
	task.fileAgeDays = frequency.ageDays;
	}

	// Get recent commits for context
	const history = this.getFileHistory(fullPath, 10);
	if (history.length > 0) {
	task.recentCommits = history.slice(0, 5).map(c => ({
	message: c.message,
	type: c.type,
	isBreaking: c.isBreaking,
	author: c.author,
	date: c.date
	}));

	// Check if file has breaking changes
	task.hasBreakingChanges = history.some(c => c.isBreaking);

	// Check if file is feature-heavy
	const featureCommits = history.filter(c => c.type === 'feat').length;
	task.isFeatureFile = featureCommits > history.length * 0.3;
	}

	return task;
	}

	/**
	* Analyze entire project history
	*/
	analyzeProjectHistory() {
	if (!this.isGitRepo) return null;

	try {
	// Get all commits
	const output = execSync(
	'git log --pretty=format:"%H\|%an\|%ae\|%at\|%s" --all',
	{
	cwd: this.projectRoot,
	encoding: 'utf8',
	timeout: 30000,
	maxBuffer: 10 * 1024 * 1024 // 10MB buffer
	}
	);

	const commits = this.parseLogOutput(output);

	// Statistics
	const typeCount = {};
	let breakingChanges = 0;
	const authors = new Set();

	for (const commit of commits) {
	typeCount[commit.type] = (typeCount[commit.type] \|\| 0) + 1;
	if (commit.isBreaking) breakingChanges++;
	authors.add(commit.author);
	}

	return {
	totalCommits: commits.length,
	totalAuthors: authors.size,
	breakingChanges,
	typeDistribution: typeCount,
	firstCommit: commits[commits.length - 1]?.date,
	lastCommit: commits[0]?.date,
	commits: commits.slice(0, 100) // Keep last 100
	};
	} catch (error) {
	return null;
	}
	}

	/**
	* Get contributors statistics
	*/
	getContributors() {
	if (!this.isGitRepo) return [];

	try {
	const output = execSync(
	'git shortlog -sn --all --no-merges',
	{
	cwd: this.projectRoot,
	encoding: 'utf8',
	timeout: 10000
	}
	);

	const lines = output.trim().split('\n');
	return lines.map(line => {
	const match = line.trim().match(/^(\d+)\s+(.+)$/);
	if (match) {
	return {
	commits: parseInt(match[1]),
	name: match[2]
	};
	}
	return null;
	}).filter(Boolean);
	} catch (error) {
	return [];
	}
	}
	}

	module.exports = GitContextAnalyzer;