vibeman 0.0.5 → 0.0.6

package/dist/runtime/api/vcs/git-history-service.js

@@ -1,228 +0,0 @@
-import { simpleGit } from 'simple-git';
-import { getProjectRoot } from '../lib/server/project-root.js';
-import { log } from '../lib/logger.js';
-import path from 'path';
-export class GitHistoryService {
-    constructor(projectRoot = getProjectRoot()) {
-        this.projectRoot = projectRoot;
-        this.git = simpleGit(projectRoot);
-    }
-    /**
-     * Get the history of changes for a specific task file
-     */
-    async getTaskHistory(taskId, limit = 50) {
-        try {
-            const taskFilePath = path.join('.vibeman', 'tasks', `${taskId}.md`);
-            // Check if the task file exists in the current working directory
-            const taskExists = await this.git.raw(['ls-files', taskFilePath]).then((output) => output.trim().length > 0, () => false);
-            if (!taskExists) {
-                // File doesn't exist in Git, return empty history
-                return [];
-            }
-            // Use --follow to track file through renames and --no-merges to avoid merge commits
-            const logResult = await this.git.raw([
-                'log',
-                '--follow',
-                '--no-merges',
-                '--pretty=format:%H|%h|%an|%ad|%s',
-                '--date=iso',
-                `--max-count=${limit}`,
-                '--',
-                taskFilePath,
-            ]);
-            if (!logResult.trim()) {
-                return [];
-            }
-            const commits = logResult.trim().split('\n');
-            const history = [];
-            for (const commitLine of commits) {
-                const [hash, shortHash, author, dateStr, ...messageParts] = commitLine.split('|');
-                const message = messageParts.join('|'); // Rejoin in case message contains |
-                if (!hash || !shortHash || !author || !dateStr) {
-                    continue;
-                }
-                try {
-                    // Get the diff stats for this specific file in this commit
-                    const stats = await this.getCommitStats(hash, taskFilePath);
-                    history.push({
-                        commitHash: hash,
-                        shortHash,
-                        author,
-                        date: new Date(dateStr),
-                        message,
-                        changes: stats,
-                    });
-                }
-                catch (error) {
-                    log.warn('Failed to get stats for commit', { hash, error }, 'git-history-service');
-                    // Add entry without stats
-                    history.push({
-                        commitHash: hash,
-                        shortHash,
-                        author,
-                        date: new Date(dateStr),
-                        message,
-                        changes: { additions: 0, deletions: 0 },
-                    });
-                }
-            }
-            return history;
-        }
-        catch (error) {
-            log.error('Failed to get task history', { taskId, error }, 'git-history-service');
-            throw new Error(`Failed to retrieve history for task ${taskId}: ${String(error)}`);
-        }
-    }
-    /**
-     * Get the content of a task file at a specific commit
-     */
-    async getTaskVersionContent(taskId, commitHash) {
-        try {
-            const taskFilePath = path.join('.vibeman', 'tasks', `${taskId}.md`);
-            // Get the file content at the specific commit
-            const content = await this.git.show([`${commitHash}:${taskFilePath}`]);
-            // Get commit information
-            const commitInfo = await this.git.raw([
-                'show',
-                '--pretty=format:%an|%ad',
-                '--date=iso',
-                '--no-patch',
-                commitHash,
-            ]);
-            const [author, dateStr] = commitInfo.trim().split('|');
-            return {
-                commitHash,
-                content,
-                date: new Date(dateStr),
-                author: author || 'Unknown',
-            };
-        }
-        catch (error) {
-            log.error('Failed to get task version content', { taskId, commitHash, error }, 'git-history-service');
-            throw new Error(`Failed to retrieve content for task ${taskId} at commit ${commitHash}: ${String(error)}`);
-        }
-    }
-    /**
-     * Get the diff between two versions of a task file
-     */
-    async getTaskDiff(taskId, fromHash, toHash) {
-        try {
-            const taskFilePath = path.join('.vibeman', 'tasks', `${taskId}.md`);
-            // Get the diff between two commits for the specific file
-            const diff = await this.git.raw(['diff', `${fromHash}..${toHash}`, '--', taskFilePath]);
-            // Get diff stats
-            const stats = await this.git.raw([
-                'diff',
-                '--numstat',
-                `${fromHash}..${toHash}`,
-                '--',
-                taskFilePath,
-            ]);
-            let additions = 0;
-            let deletions = 0;
-            if (stats.trim()) {
-                const [addStr, delStr] = stats.trim().split('\t');
-                additions = parseInt(addStr, 10) || 0;
-                deletions = parseInt(delStr, 10) || 0;
-            }
-            return {
-                fromHash,
-                toHash,
-                diff,
-                additions,
-                deletions,
-            };
-        }
-        catch (error) {
-            log.error('Failed to get task diff', { taskId, fromHash, toHash, error }, 'git-history-service');
-            throw new Error(`Failed to get diff for task ${taskId} between ${fromHash} and ${toHash}: ${String(error)}`);
-        }
-    }
-    /**
-     * Check if Git repository exists and is properly configured
-     */
-    async isGitRepositoryAvailable() {
-        try {
-            const isRepo = await this.git.checkIsRepo();
-            return isRepo;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Get commit statistics for a specific file in a commit
-     */
-    async getCommitStats(commitHash, filePath) {
-        try {
-            // Get the parent commit hash
-            const parentHash = await this.git.raw(['rev-parse', `${commitHash}^`]).catch(() => {
-                // This is likely the initial commit, compare against empty tree
-                return '4b825dc642cb6eb9a060e54bf8d69288fbee4904'; // Git's empty tree hash
-            });
-            const stats = await this.git.raw([
-                'diff',
-                '--numstat',
-                parentHash.trim(),
-                commitHash,
-                '--',
-                filePath,
-            ]);
-            if (!stats.trim()) {
-                return { additions: 0, deletions: 0 };
-            }
-            const [addStr, delStr] = stats.trim().split('\t');
-            return {
-                additions: parseInt(addStr, 10) || 0,
-                deletions: parseInt(delStr, 10) || 0,
-            };
-        }
-        catch {
-            return { additions: 0, deletions: 0 };
-        }
-    }
-    /**
-     * Check if a task file has been renamed or moved by tracking it through Git history
-     */
-    async getTaskFileRenames(taskId) {
-        try {
-            const taskFilePath = path.join('.vibeman', 'tasks', `${taskId}.md`);
-            // Use git log --follow --name-status to track renames
-            const logResult = await this.git.raw([
-                'log',
-                '--follow',
-                '--name-status',
-                '--pretty=format:%H',
-                '--',
-                taskFilePath,
-            ]);
-            const renames = [];
-            const lines = logResult.trim().split('\n');
-            let currentCommit = '';
-            for (const line of lines) {
-                if (line.match(/^[a-f0-9]{40}$/)) {
-                    // This is a commit hash
-                    currentCommit = line;
-                }
-                else if (line.startsWith('R') && currentCommit) {
-                    // This is a rename operation (R100, R090, etc.)
-                    const parts = line.split('\t');
-                    if (parts.length >= 3) {
-                        const oldPath = parts[1];
-                        const newPath = parts[2];
-                        renames.push({
-                            oldPath,
-                            newPath,
-                            commitHash: currentCommit,
-                        });
-                    }
-                }
-            }
-            return renames;
-        }
-        catch (error) {
-            log.warn('Failed to get task file renames', { taskId, error }, 'git-history-service');
-            return [];
-        }
-    }
-}

package/dist/runtime/api/vcs/git-service.d.ts

@@ -1,136 +0,0 @@
-import { SimpleGit, VersionResult } from 'simple-git';
-import { Task } from '../types/index.js';
-export interface GitConfig {
-    remoteUrl?: string;
-    defaultBranch?: string;
-}
-export interface BranchInfo {
-    name: string;
-    exists: boolean;
-    isCurrentBranch: boolean;
-}
-export interface CommitInfo {
-    hash: string;
-    message: string;
-    author: string;
-    date: Date;
-}
-export interface WorktreeCreationResult {
-    path: string;
-    branchName: string;
-    existed: boolean;
-}
-export declare class GitService {
-    private git;
-    private config;
-    private projectRoot;
-    constructor(projectRoot?: string, config?: GitConfig);
-    getProjectRoot(): string;
-    /**
-     * Validate Git repository exists and is properly configured
-     */
-    initializeRepository(): Promise<void>;
-    /**
-     * Get current Git status
-     */
-    getStatus(): Promise<{
-        current: string;
-        staged: string[];
-        modified: string[];
-        untracked: string[];
-        ahead: number;
-        behind: number;
-    }>;
-    /**
-     * Generate branch name from task
-     */
-    generateBranchName(task: Task): string;
-    /**
-     * Create a new branch for a task
-     */
-    createBranch(task: Task, baseBranch?: string): Promise<BranchInfo>;
-    /**
-     * Stage and commit changes
-     */
-    commitChanges(task: Task, message?: string, files?: string[]): Promise<CommitInfo>;
-    /**
-     * Generate standardized commit message
-     */
-    generateCommitMessage(task: Task): string;
-    /**
-     * Get commit history for current branch
-     */
-    getCommitHistory(maxCount?: number): Promise<CommitInfo[]>;
-    /**
-     * Get Git version information
-     */
-    getGitVersion(): Promise<VersionResult>;
-    /**
-     * Check whether a path is ignored by git.
-     */
-    isIgnored(relativePath: string): Promise<boolean>;
-    /**
-     * Get the current HEAD commit hash
-     */
-    getHeadCommitHash(short?: boolean): Promise<string>;
-    /**
-     * List all worktrees in the repository
-     */
-    listWorktrees(): Promise<{
-        path: string;
-        branch: string;
-        prunable?: boolean;
-    }[]>;
-    /**
-     * Parse git worktree list output
-     */
-    private parseWorktreeList;
-    /**
-     * Create a new worktree
-     */
-    createWorktree(worktreePath: string, branchName: string, branchExists?: boolean): Promise<void>;
-    /**
-     * Remove a worktree
-     */
-    removeWorktree(worktreePath: string, force?: boolean): Promise<void>;
-    /**
-     * Prune stale worktrees
-     */
-    pruneWorktrees(): Promise<void>;
-    /**
-     * Delete a local branch
-     */
-    deleteLocalBranch(branchName: string, force?: boolean): Promise<void>;
-    /**
-     * Check if branch exists locally
-     */
-    branchExists(branchName: string): Promise<boolean>;
-    /**
-     * Sync with remote repository
-     */
-    syncWithRemote(branchName?: string): Promise<void>;
-    /**
-     * Get Git instance for a specific directory
-     */
-    getGitInstance(directory: string): SimpleGit;
-    /**
-     * Check Git status for a specific directory
-     */
-    getGitStatus(directory: string): Promise<{
-        modified: string[];
-        staged: string[];
-        not_added: string[];
-    }>;
-    /**
-     * Check if directory has uncommitted changes
-     */
-    hasUncommittedChanges(directory?: string): Promise<boolean>;
-    /**
-     * Get log for a specific directory/worktree
-     */
-    getLog(directory: string, options: string[]): Promise<any>;
-    /**
-     * Push branch from specific directory
-     */
-    pushFromDirectory(directory: string, remote: string, branchName: string, options?: string[]): Promise<void>;
-}

package/dist/runtime/api/vcs/git-service.js

@@ -1,307 +0,0 @@
-import { simpleGit } from 'simple-git';
-import { log } from '../lib/logger.js';
-import { getProjectRoot } from '../lib/server/project-root.js';
-export class GitService {
-    constructor(projectRoot = getProjectRoot(), config = {}) {
-        this.projectRoot = projectRoot;
-        this.config = config;
-        this.git = simpleGit(projectRoot);
-    }
-    getProjectRoot() {
-        return this.projectRoot;
-    }
-    /**
-     * Validate Git repository exists and is properly configured
-     */
-    async initializeRepository() {
-        const isRepo = await this.git.checkIsRepo();
-        if (!isRepo) {
-            const error = new Error(`Directory ${this.projectRoot} is not a Git repository. Please run 'git init' first.`);
-            log.error('Git repository not found', error, 'git-service');
-            throw error;
-        }
-        // Set up basic Git configuration if not present
-        try {
-            await this.git.raw(['config', 'user.name']);
-        }
-        catch {
-            await this.git.addConfig('user.name', 'Vibeman');
-            await this.git.addConfig('user.email', 'vibeman@localhost');
-            log.info('Set default Git user configuration', undefined, 'git-service');
-        }
-    }
-    /**
-     * Get current Git status
-     */
-    async getStatus() {
-        const status = await this.git.status();
-        return {
-            current: status.current || 'main',
-            staged: status.staged,
-            modified: status.modified,
-            untracked: status.not_added,
-            ahead: status.ahead,
-            behind: status.behind,
-        };
-    }
-    /**
-     * Generate branch name from task
-     */
-    generateBranchName(task) {
-        const typePrefix = {
-            feature: 'feat',
-            bug: 'fix',
-            chore: 'chore',
-            refactor: 'refactor',
-            test: 'test',
-            doc: 'docs',
-        }[task.type];
-        // Keep branch concise and deterministic, use only the task id
-        return `${typePrefix}/${task.id.toLowerCase()}`;
-    }
-    /**
-     * Create a new branch for a task
-     */
-    async createBranch(task, baseBranch) {
-        const branchName = this.generateBranchName(task);
-        const base = baseBranch || this.config.defaultBranch || 'main';
-        // Check if branch already exists
-        const branches = await this.git.branchLocal();
-        const exists = branches.all.includes(branchName);
-        if (exists) {
-            log.info('Branch already exists', { branchName }, 'git-service');
-            await this.git.checkout(branchName);
-            return {
-                name: branchName,
-                exists: true,
-                isCurrentBranch: true,
-            };
-        }
-        // Ensure we're on the base branch and it's up to date
-        try {
-            await this.git.checkout(base);
-            await this.git.pull('origin', base);
-        }
-        catch (error) {
-            log.warn('Could not update base branch', error, 'git-service');
-        }
-        // Create and checkout new branch
-        await this.git.checkoutLocalBranch(branchName);
-        log.info('Created and checked out branch', { branchName }, 'git-service');
-        return {
-            name: branchName,
-            exists: false,
-            isCurrentBranch: true,
-        };
-    }
-    /**
-     * Stage and commit changes
-     */
-    async commitChanges(task, message, files = ['.']) {
-        // Stage only the specified files
-        for (const file of files) {
-            await this.git.add(file);
-        }
-        // Generate commit message if not provided
-        const commitMessage = message || this.generateCommitMessage(task);
-        // Commit only the specified files (avoid committing other pre-staged changes)
-        const result = await this.git.commit(commitMessage, files);
-        log.info('Committed changes', { commit: result.commit }, 'git-service');
-        return {
-            hash: result.commit,
-            message: commitMessage,
-            author: 'Vibeman',
-            date: new Date(),
-        };
-    }
-    /**
-     * Generate standardized commit message
-     */
-    generateCommitMessage(task) {
-        const typeMap = {
-            feature: 'feat',
-            bug: 'fix',
-            chore: 'chore',
-            refactor: 'refactor',
-            test: 'test',
-            doc: 'docs',
-        };
-        const type = typeMap[task.type];
-        const scope = task.tags.length > 0 ? `(${task.tags[0]})` : '';
-        return `${type}${scope}: ${task.title}\n\n${task.id}: ${task.title}\n\nImplemented via Vibeman`;
-    }
-    /**
-     * Get commit history for current branch
-     */
-    async getCommitHistory(maxCount = 10) {
-        const log = await this.git.log({ maxCount });
-        return log.all.map((commit) => ({
-            hash: commit.hash,
-            message: commit.message,
-            author: commit.author_name,
-            date: new Date(commit.date),
-        }));
-    }
-    /**
-     * Get Git version information
-     */
-    async getGitVersion() {
-        return await this.git.version();
-    }
-    /**
-     * Check whether a path is ignored by git.
-     */
-    async isIgnored(relativePath) {
-        try {
-            await this.git.raw(['check-ignore', '-q', relativePath]);
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Get the current HEAD commit hash
-     */
-    async getHeadCommitHash(short = true) {
-        const args = short ? ['--short', 'HEAD'] : ['HEAD'];
-        const hash = await this.git.revparse(args);
-        return hash.trim();
-    }
-    /**
-     * List all worktrees in the repository
-     */
-    async listWorktrees() {
-        const worktreeList = await this.git.raw(['worktree', 'list', '--porcelain']);
-        return this.parseWorktreeList(worktreeList);
-    }
-    /**
-     * Parse git worktree list output
-     */
-    parseWorktreeList(output) {
-        const lines = output.trim().split('\n');
-        const worktrees = [];
-        let currentWorktree = {};
-        for (const line of lines) {
-            if (line.startsWith('worktree ')) {
-                if (currentWorktree.path) {
-                    worktrees.push(currentWorktree);
-                }
-                currentWorktree = { path: line.substring(9) };
-            }
-            else if (line.startsWith('branch ')) {
-                const ref = line.substring(7);
-                // Strip refs/heads/ prefix if present for readability
-                currentWorktree.branch = ref.startsWith('refs/heads/') ? ref.substring(11) : ref;
-            }
-            else if (line.startsWith('prunable')) {
-                currentWorktree.prunable = true;
-            }
-        }
-        if (currentWorktree.path) {
-            worktrees.push(currentWorktree);
-        }
-        return worktrees;
-    }
-    /**
-     * Create a new worktree
-     */
-    async createWorktree(worktreePath, branchName, branchExists) {
-        if (branchExists) {
-            // Create worktree attached to existing branch (no -b)
-            await this.git.raw(['worktree', 'add', worktreePath, branchName]);
-        }
-        else {
-            // Create worktree and new branch
-            await this.git.raw(['worktree', 'add', worktreePath, '-b', branchName]);
-        }
-    }
-    /**
-     * Remove a worktree
-     */
-    async removeWorktree(worktreePath, force = false) {
-        const args = ['worktree', 'remove', worktreePath];
-        if (force)
-            args.push('--force');
-        await this.git.raw(args);
-    }
-    /**
-     * Prune stale worktrees
-     */
-    async pruneWorktrees() {
-        await this.git.raw(['worktree', 'prune']);
-    }
-    /**
-     * Delete a local branch
-     */
-    async deleteLocalBranch(branchName, force = false) {
-        await this.git.deleteLocalBranch(branchName, force);
-    }
-    /**
-     * Check if branch exists locally
-     */
-    async branchExists(branchName) {
-        const localBranches = await this.git.branchLocal();
-        return !!localBranches.all.find((b) => b === branchName);
-    }
-    /**
-     * Sync with remote repository
-     */
-    async syncWithRemote(branchName) {
-        try {
-            const status = await this.git.status();
-            const currentBranch = branchName || status.current;
-            if (currentBranch && currentBranch !== 'HEAD') {
-                await this.git.fetch();
-                log.info('Synced with remote repository', undefined, 'git-service');
-            }
-        }
-        catch (error) {
-            log.warn('Could not sync with remote', error, 'git-service');
-        }
-    }
-    /**
-     * Get Git instance for a specific directory
-     */
-    getGitInstance(directory) {
-        return simpleGit(directory);
-    }
-    /**
-     * Check Git status for a specific directory
-     */
-    async getGitStatus(directory) {
-        const git = this.getGitInstance(directory);
-        const status = await git.status();
-        return {
-            modified: status.modified,
-            staged: status.staged,
-            not_added: status.not_added,
-        };
-    }
-    /**
-     * Check if directory has uncommitted changes
-     */
-    async hasUncommittedChanges(directory = this.projectRoot) {
-        try {
-            const status = await this.getGitStatus(directory);
-            return status.modified.length > 0 || status.staged.length > 0 || status.not_added.length > 0;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Get log for a specific directory/worktree
-     */
-    async getLog(directory, options) {
-        const git = this.getGitInstance(directory);
-        return await git.log(options);
-    }
-    /**
-     * Push branch from specific directory
-     */
-    async pushFromDirectory(directory, remote, branchName, options = []) {
-        const git = this.getGitInstance(directory);
-        await git.push(remote, branchName, options);
-    }
-}