vibeman 0.0.3 → 0.0.6

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

@@ -1,284 +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);
-    }
-    /**
-     * 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();
-    }
-    /**
-     * 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);
-    }
-}

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

@@ -1,93 +0,0 @@
-import { EventEmitter } from 'events';
-import { Task, WorktreeInfo as BaseWorktreeInfo, WorktreeConfig } from '../types/index.js';
-import { GitService } from './git-service.js';
-export interface WorktreeInfo extends BaseWorktreeInfo {
-    git: GitService;
-}
-export declare class WorktreeService extends EventEmitter {
-    private worktrees;
-    private inFlightCreates;
-    private gitService;
-    private projectRoot;
-    private config;
-    private initialized;
-    private initPromise;
-    constructor(projectRoot?: string, gitService?: GitService);
-    /**
-     * Initialize the worktree service
-     */
-    initialize(): Promise<void>;
-    /**
-     * Recover existing worktrees after restart
-     */
-    private recoverExistingWorktrees;
-    /**
-     * Extract task ID from worktree path
-     * TODO: need to improve this to be more robust
-     */
-    private extractTaskIdFromPath;
-    /**
-     * Create a new worktree for a task
-     */
-    createWorktree(task: Task): Promise<WorktreeInfo>;
-    /**
-     * Symlink essential files to worktree
-     */
-    private symlinkEssentialFiles;
-    /**
-     * Get worktree info for a task
-     */
-    getWorktree(taskId: string): WorktreeInfo | null;
-    /**
-     * List all Git worktrees with connection status to Vibeman tasks
-     */
-    listWorktrees(): Promise<Array<BaseWorktreeInfo & {
-        isConnectedToTask: boolean;
-    }>>;
-    /**
-     * Unified cleanup: remove branch first, then worktree
-     * For connected worktrees, use taskId; for unconnected, use worktreePath and branchName
-     */
-    cleanupWorktree(params: {
-        taskId?: string;
-        worktreePath?: string;
-        branchName?: string;
-        isConnectedToTask: boolean;
-        force?: boolean;
-    }): Promise<void>;
-    /**
-     * Delete a worktree
-     */
-    deleteWorktree(taskId: string, force?: boolean): Promise<void>;
-    /**
-     * Create pull request from worktree branch
-     */
-    createPullRequest(taskId: string, _baseBranch?: string): Promise<{
-        success: boolean;
-        pullRequest?: any;
-        error?: string;
-    }>;
-    /**
-     * Sync worktree state with Git (public method for manual refresh)
-     */
-    syncWorktreeState(): Promise<void>;
-    /**
-     * Validate Git version compatibility for worktrees
-     */
-    private validateGitVersion;
-    /**
-     * Get worktree counts (synchronous, from memory)
-     */
-    getWorktreeCounts(): {
-        active: number;
-        total: number;
-    };
-    /**
-     * Get current configuration
-     */
-    getConfig(): WorktreeConfig;
-    /**
-     * Get GitService instance for advanced operations
-     */
-    getGitService(): GitService;
-}