vibeman 0.0.3 → 0.0.6

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

@@ -1,506 +0,0 @@
-import { EventEmitter } from 'events';
-import { GitService } from './git-service.js';
-import { log } from '../lib/logger.js';
-import { getSettingsService } from '../settings-service.js';
-import { getProjectRoot } from '../lib/server/project-root.js';
-import path from 'path';
-import fs from 'fs/promises';
-export class WorktreeService extends EventEmitter {
-    constructor(projectRoot = getProjectRoot(), gitService) {
-        super();
-        this.worktrees = new Map();
-        this.inFlightCreates = new Map();
-        this.initialized = false;
-        this.initPromise = null;
-        this.projectRoot = projectRoot;
-        this.gitService = gitService || new GitService(projectRoot);
-        // Load configuration from settings, with fallback to environment then default
-        const settingsWorktreePath = (() => {
-            try {
-                const svc = getSettingsService();
-                const s = svc.getSettings();
-                return s?.development?.git?.worktreePath;
-            }
-            catch {
-                return undefined;
-            }
-        })();
-        this.config = {
-            // Default to parent directory of the repo
-            worktreePath: settingsWorktreePath || '../',
-        };
-    }
-    /**
-     * Initialize the worktree service
-     */
-    async initialize() {
-        if (this.initialized)
-            return;
-        if (this.initPromise)
-            return this.initPromise;
-        this.initPromise = (async () => {
-            try {
-                // Check if project root exists and is a Git repository
-                await fs.access(this.projectRoot);
-                // Ensure Git is available and version is compatible
-                await this.validateGitVersion();
-                // Ensure recovery of any existing worktrees
-                await this.recoverExistingWorktrees();
-                this.initialized = true;
-                log.debug('WorktreeService initialized', undefined, 'worktree-service');
-            }
-            catch (error) {
-                log.error('WorktreeService initialization failed, disabling worktrees', error, 'worktree-service');
-            }
-        })();
-        try {
-            await this.initPromise;
-        }
-        finally {
-            this.initPromise = null;
-        }
-    }
-    /**
-     * Recover existing worktrees after restart
-     */
-    async recoverExistingWorktrees() {
-        try {
-            const gitWorktrees = await this.gitService.listWorktrees();
-            const validTaskIds = new Set();
-            let sawPrunable = false;
-            // First, recover valid worktrees from Git
-            const baseDir = path.resolve(this.projectRoot, this.config.worktreePath);
-            for (const worktree of gitWorktrees) {
-                if (worktree.prunable) {
-                    sawPrunable = true;
-                    continue;
-                }
-                // Only consider worktrees under the configured base directory
-                const wtPath = path.resolve(worktree.path);
-                if (wtPath.startsWith(baseDir + path.sep) || wtPath === baseDir) {
-                    const taskId = this.extractTaskIdFromPath(worktree.path);
-                    if (taskId) {
-                        try {
-                            // Ensure the path exists before creating a git instance
-                            await fs.stat(worktree.path);
-                            const worktreeInfo = {
-                                taskId,
-                                path: worktree.path,
-                                branchName: worktree.branch,
-                                git: new GitService(worktree.path),
-                            };
-                            this.worktrees.set(taskId, worktreeInfo);
-                            validTaskIds.add(taskId);
-                            log.debug('Recovered worktree for task', { taskId }, 'worktree-service');
-                        }
-                        catch {
-                            // Path no longer exists; mark for prune
-                            sawPrunable = true;
-                        }
-                    }
-                }
-            }
-            if (sawPrunable) {
-                try {
-                    await this.gitService.pruneWorktrees();
-                    log.info('Pruned stale worktree entries during recovery', undefined, 'worktree-service');
-                }
-                catch (e) {
-                    log.error('Failed to prune stale worktrees during recovery', e, 'worktree-service');
-                }
-            }
-            // Remove any in-memory worktrees that no longer exist in Git
-            const inMemoryTaskIds = Array.from(this.worktrees.keys());
-            for (const taskId of inMemoryTaskIds) {
-                if (!validTaskIds.has(taskId)) {
-                    this.worktrees.delete(taskId);
-                    log.info('Removed stale worktree reference', { taskId }, 'worktree-service');
-                }
-            }
-        }
-        catch (error) {
-            log.error('Could not recover existing worktrees', error, 'worktree-service');
-        }
-    }
-    /**
-     * Extract task ID from worktree path
-     * TODO: need to improve this to be more robust
-     */
-    extractTaskIdFromPath(worktreePath) {
-        const basename = path.basename(worktreePath);
-        // Worktree directory format: {taskId}
-        // Accept IDs like FEATURE-001, FEAT-ABC12, BUG-4XYZ9, FEAT-EDITOR-EXP
-        // Previously this only allowed a single hyphen; expand to multiple hyphen-separated segments.
-        return /^[A-Z0-9]+(?:-[A-Z0-9]+)+$/i.test(basename) ? basename : null;
-    }
-    /**
-     * Create a new worktree for a task
-     */
-    async createWorktree(task) {
-        // Check if worktree already exists for this task
-        if (this.worktrees.has(task.id)) {
-            const existing = this.worktrees.get(task.id);
-            log.info('Using existing worktree for task', { taskId: task.id }, 'worktree-service');
-            return existing;
-        }
-        // Deduplicate concurrent create calls per task
-        const existingPromise = this.inFlightCreates.get(task.id);
-        if (existingPromise)
-            return existingPromise;
-        // Generate branch name and worktree path
-        const branchName = this.gitService.generateBranchName(task);
-        const baseDir = path.resolve(this.projectRoot, this.config.worktreePath);
-        // Ensure base directory exists
-        await fs.mkdir(baseDir, { recursive: true });
-        const worktreePath = path.resolve(baseDir, task.id);
-        const createPromise = (async () => {
-            try {
-                // Ensure we're in sync with remote
-                await this.gitService.syncWithRemote();
-                // Check existing worktrees and branches to allow reuse on reruns
-                const gitWorktrees = await this.gitService.listWorktrees();
-                // Try to find an existing worktree for this branch or path
-                const existingByBranch = gitWorktrees.find((w) => w.branch === branchName);
-                const existingByPath = gitWorktrees.find((w) => path.resolve(w.path) === path.resolve(worktreePath));
-                if (existingByBranch && !existingByBranch.prunable) {
-                    // Reuse existing worktree by branch
-                    const resolvedPath = path.resolve(existingByBranch.path);
-                    await this.symlinkEssentialFiles(resolvedPath);
-                    const worktreeInfo = {
-                        taskId: task.id,
-                        path: resolvedPath,
-                        branchName,
-                        git: new GitService(resolvedPath),
-                    };
-                    this.worktrees.set(task.id, worktreeInfo);
-                    log.info('Reused existing worktree for branch', { taskId: task.id, path: resolvedPath, branchName }, 'worktree-service');
-                    this.emit('worktreeCreated', worktreeInfo);
-                    return worktreeInfo;
-                }
-                if (existingByPath && !existingByPath.prunable) {
-                    // Path already registered as a worktree; use it
-                    const resolvedPath = path.resolve(existingByPath.path);
-                    await this.symlinkEssentialFiles(resolvedPath);
-                    const worktreeInfo = {
-                        taskId: task.id,
-                        path: resolvedPath,
-                        branchName: existingByPath.branch || branchName,
-                        git: new GitService(resolvedPath),
-                    };
-                    this.worktrees.set(task.id, worktreeInfo);
-                    log.info('Reused existing worktree by path', { taskId: task.id, path: resolvedPath, branchName: worktreeInfo.branchName }, 'worktree-service');
-                    this.emit('worktreeCreated', worktreeInfo);
-                    return worktreeInfo;
-                }
-                // If we found prunable entries for this path or branch, prune before attempting to add
-                if ((existingByBranch && existingByBranch.prunable) ||
-                    (existingByPath && existingByPath.prunable)) {
-                    try {
-                        await this.gitService.pruneWorktrees();
-                        log.info('Pruned stale worktree entries', { branchName, worktreePath }, 'worktree-service');
-                    }
-                    catch (e) {
-                        log.error('Failed to prune worktrees', e, 'worktree-service');
-                    }
-                }
-                // Determine if branch already exists locally
-                const branchExists = await this.gitService.branchExists(branchName);
-                // Create the worktree using git service
-                await this.gitService.createWorktree(worktreePath, branchName, branchExists);
-                // Copy essential files (like .env) to the worktree
-                await this.symlinkEssentialFiles(worktreePath);
-                const worktreeInfo = {
-                    taskId: task.id,
-                    path: worktreePath,
-                    branchName,
-                    git: new GitService(worktreePath),
-                };
-                this.worktrees.set(task.id, worktreeInfo);
-                log.info('Created worktree', { taskId: task.id, path: worktreePath }, 'worktree-service');
-                this.emit('worktreeCreated', worktreeInfo);
-                return worktreeInfo;
-            }
-            catch (error) {
-                log.error('Failed to create worktree', error, 'worktree-service');
-                // Cleanup on failure
-                try {
-                    await fs.rm(worktreePath, { recursive: true, force: true });
-                }
-                catch {
-                    // Ignore cleanup errors
-                }
-                throw new Error(`Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            finally {
-                // Clear in-flight marker
-                this.inFlightCreates.delete(task.id);
-            }
-        })();
-        this.inFlightCreates.set(task.id, createPromise);
-        return createPromise;
-    }
-    /**
-     * Symlink essential files to worktree
-     */
-    async symlinkEssentialFiles(worktreePath) {
-        // Link only .env and .env* files in the project root.
-        let entries = [];
-        try {
-            entries = (await fs.readdir(this.projectRoot)).filter((name) => name.startsWith('.env'));
-        }
-        catch {
-            entries = [];
-        }
-        for (const name of entries) {
-            const sourcePath = path.join(this.projectRoot, name);
-            const targetPath = path.join(worktreePath, name);
-            try {
-                await fs.stat(sourcePath);
-                await fs.mkdir(path.dirname(targetPath), { recursive: true });
-                // Ensure idempotency: if target exists and links to source, skip
-                let shouldCreate = true;
-                try {
-                    const lst = await fs.lstat(targetPath);
-                    if (lst.isSymbolicLink()) {
-                        const linkTarget = await fs.readlink(targetPath);
-                        const resolved = path.resolve(path.dirname(targetPath), linkTarget);
-                        if (resolved === sourcePath) {
-                            shouldCreate = false;
-                        }
-                    }
-                }
-                catch {
-                    // target missing, proceed
-                }
-                if (shouldCreate) {
-                    // Remove any existing file/dir and create a symlink
-                    await fs.rm(targetPath, { recursive: true, force: true });
-                    const relative = path.relative(path.dirname(targetPath), sourcePath);
-                    await fs.symlink(relative, targetPath);
-                    log.debug('Symlinked to worktree', { name }, 'worktree-service');
-                }
-            }
-            catch {
-                // Ignore missing source or failures
-            }
-        }
-    }
-    /**
-     * Get worktree info for a task
-     */
-    getWorktree(taskId) {
-        return this.worktrees.get(taskId) || null;
-    }
-    /**
-     * List all Git worktrees with connection status to Vibeman tasks
-     */
-    async listWorktrees() {
-        try {
-            const gitWorktrees = await this.gitService.listWorktrees();
-            const result = [];
-            for (const gitWorktree of gitWorktrees) {
-                if (gitWorktree.prunable) {
-                    continue; // Skip prunable worktrees
-                }
-                // Skip main branch worktree
-                if (gitWorktree.branch === 'main' || gitWorktree.branch === 'master') {
-                    continue;
-                }
-                const taskId = this.extractTaskIdFromPath(gitWorktree.path);
-                const isConnectedToTask = taskId ? this.worktrees.has(taskId) : false;
-                result.push({
-                    taskId: taskId || path.basename(gitWorktree.path),
-                    path: gitWorktree.path,
-                    branchName: gitWorktree.branch,
-                    isConnectedToTask,
-                });
-            }
-            return result;
-        }
-        catch (error) {
-            log.error('Failed to list all worktrees', error, 'worktree-service');
-            throw new Error(`Failed to list all worktrees: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Unified cleanup: remove branch first, then worktree
-     * For connected worktrees, use taskId; for unconnected, use worktreePath and branchName
-     */
-    async cleanupWorktree(params) {
-        const { taskId, worktreePath, branchName, isConnectedToTask, force = false } = params;
-        try {
-            let actualWorktreePath;
-            let actualBranchName;
-            if (isConnectedToTask && taskId) {
-                // For connected worktrees, get info from tracked worktrees
-                const worktree = this.worktrees.get(taskId);
-                if (!worktree) {
-                    throw new Error(`Worktree for task ${taskId} not found`);
-                }
-                actualWorktreePath = worktree.path;
-                actualBranchName = worktree.branchName;
-                // Check for uncommitted changes unless forced
-                if (!force) {
-                    const hasChanges = await this.gitService.hasUncommittedChanges(actualWorktreePath);
-                    if (hasChanges) {
-                        throw new Error(`Worktree has uncommitted changes. Use force=true to delete anyway.`);
-                    }
-                }
-            }
-            else {
-                // For unconnected worktrees, use provided paths
-                if (!worktreePath || !branchName) {
-                    throw new Error('worktreePath and branchName are required for unconnected worktrees');
-                }
-                actualWorktreePath = worktreePath;
-                actualBranchName = branchName;
-            }
-            // Step 1: Try to remove the branch first (if it's not main/master)
-            if (actualBranchName !== 'main' && actualBranchName !== 'master') {
-                try {
-                    await this.gitService.deleteLocalBranch(actualBranchName, true);
-                    log.info('Deleted branch', { branchName: actualBranchName }, 'worktree-service');
-                }
-                catch (error) {
-                    // Log but continue - branch might not exist or already deleted
-                    log.warn('Could not delete branch, continuing with worktree removal', {
-                        branchName: actualBranchName,
-                        error: error instanceof Error ? error.message : String(error),
-                    }, 'worktree-service');
-                }
-            }
-            // Step 2: Remove the worktree
-            await this.gitService.removeWorktree(actualWorktreePath, force);
-            // Step 3: Clean up tracking if it was a connected worktree
-            if (isConnectedToTask && taskId) {
-                this.worktrees.delete(taskId);
-                this.emit('worktreeDeleted', taskId);
-            }
-            log.info('Successfully cleaned up worktree', {
-                taskId,
-                worktreePath: actualWorktreePath,
-                branchName: actualBranchName,
-                isConnectedToTask,
-            }, 'worktree-service');
-        }
-        catch (error) {
-            log.error('Failed to cleanup worktree', error, 'worktree-service');
-            throw new Error(`Failed to cleanup worktree: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Delete a worktree
-     */
-    async deleteWorktree(taskId, force = false) {
-        const worktree = this.worktrees.get(taskId);
-        if (!worktree) {
-            throw new Error(`Worktree for task ${taskId} not found`);
-        }
-        try {
-            // Check for uncommitted changes unless forced
-            if (!force) {
-                const hasChanges = await this.gitService.hasUncommittedChanges(worktree.path);
-                if (hasChanges) {
-                    throw new Error(`Worktree has uncommitted changes. Use force=true to delete anyway.`);
-                }
-            }
-            // Remove worktree using git service
-            await this.gitService.removeWorktree(worktree.path, force);
-            // Delete local branch if it exists and is not merged
-            try {
-                await this.gitService.deleteLocalBranch(worktree.branchName, force);
-                log.info('Deleted branch', { branchName: worktree.branchName }, 'worktree-service');
-            }
-            catch (error) {
-                log.warn('Could not delete branch', error, 'worktree-service');
-            }
-            // Remove from tracking
-            this.worktrees.delete(taskId);
-            log.info('Deleted worktree', { taskId }, 'worktree-service');
-            this.emit('worktreeDeleted', { taskId, worktree });
-        }
-        catch (error) {
-            log.error('Failed to delete worktree', error, 'worktree-service');
-            throw new Error(`Failed to delete worktree: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Create pull request from worktree branch
-     */
-    async createPullRequest(taskId, _baseBranch = 'main') {
-        const worktree = this.worktrees.get(taskId);
-        if (!worktree) {
-            return {
-                success: false,
-                error: `Worktree for task ${taskId} not found`,
-            };
-        }
-        try {
-            // Check if there are any commits in the worktree branch
-            const gitLog = await this.gitService.getLog(worktree.path, ['-n', '1']);
-            if (!gitLog.latest) {
-                return {
-                    success: false,
-                    error: 'No commits found in worktree branch',
-                };
-            }
-            // Push the branch to remote
-            await this.gitService.pushFromDirectory(worktree.path, 'origin', worktree.branchName);
-            log.info('Pushed branch for task - manual PR creation required', { taskId, branchName: worktree.branchName }, 'worktree-service');
-            return {
-                success: true,
-                error: 'Branch pushed successfully. GitHub integration removed - please create PR manually.',
-            };
-        }
-        catch (error) {
-            log.error('Failed to push branch', error, 'worktree-service');
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Sync worktree state with Git (public method for manual refresh)
-     */
-    async syncWorktreeState() {
-        await this.recoverExistingWorktrees();
-        log.info('Worktree state synchronized', undefined, 'worktree-service');
-    }
-    /**
-     * Validate Git version compatibility for worktrees
-     */
-    async validateGitVersion() {
-        try {
-            const version = await this.gitService.getGitVersion();
-            const versionNumber = parseFloat(String(version.major) + '.' + String(version.minor));
-            if (versionNumber < 2.15) {
-                log.warn('Git version not optimal for worktrees', { version: version.installed, recommended: '2.15+' }, 'worktree-service');
-            }
-        }
-        catch {
-            throw new Error('Git is not available. Please install Git 2.15+ to use worktree functionality.');
-        }
-    }
-    /**
-     * Get worktree counts (synchronous, from memory)
-     */
-    getWorktreeCounts() {
-        return {
-            active: this.worktrees.size,
-            total: this.worktrees.size,
-        };
-    }
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Get GitService instance for advanced operations
-     */
-    getGitService() {
-        return this.gitService;
-    }
-}

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

@@ -1 +0,0 @@
-export {};

package/dist/runtime/api/vcs/worktree-service.test.js

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { WorktreeService } from './worktree-service.js';
-describe('WorktreeService.extractTaskIdFromPath', () => {
-    it('accepts simple hyphenated IDs', () => {
-        const svc = new WorktreeService(process.cwd());
-        const fn = svc.extractTaskIdFromPath.bind(svc);
-        expect(fn('/tmp/FEAT-DFMXM')).toBe('FEAT-DFMXM');
-    });
-    it('accepts multi-hyphen IDs like FEAT-EDITOR-EXP', () => {
-        const svc = new WorktreeService(process.cwd());
-        const fn = svc.extractTaskIdFromPath.bind(svc);
-        expect(fn('/any/path/FEAT-EDITOR-EXP')).toBe('FEAT-EDITOR-EXP');
-    });
-    it('rejects clearly non-matching names', () => {
-        const svc = new WorktreeService(process.cwd());
-        const fn = svc.extractTaskIdFromPath.bind(svc);
-        expect(fn('/tmp/feat_editor_exp')).toBeNull();
-        expect(fn('/tmp/feat editor exp')).toBeNull();
-    });
-});

package/dist/runtime/api/workflows/quality-pipeline.d.ts

@@ -1,58 +0,0 @@
-import { QualityResults } from '../types/index.js';
-interface QualityCheck {
-    name: string;
-    command: string;
-    args: string[];
-    timeout: number;
-}
-export declare class QualityPipeline {
-    getChecksFor(): Promise<QualityCheck[]>;
-    private getChecks;
-    private detectQualityChecks;
-    private aiDetectQualityChecks;
-    private getDefaultProviderName;
-    /**
-     * Public: Detect quality checks (AI-only) and persist to settings if found.
-     * Does not execute any checks.
-     */
-    detectAndPersistChecks(workingDirectory: string): Promise<Array<{
-        name: string;
-        command: string;
-        args: string[];
-        timeout: number;
-        enabled: boolean;
-    }>>;
-    /**
-     * Run all quality checks in the specified directory
-     */
-    runChecks(workingDirectory: string): Promise<QualityResults>;
-    /**
-     * Run checks with streaming logs via callback.
-     */
-    runChecksStreaming(workingDirectory: string, onLog?: (line: string) => void | Promise<void>): Promise<QualityResults>;
-    /**
-     * Run a single quality check
-     */
-    private runCheck;
-    /**
-     * Run a command and return its output
-     */
-    private runCommand;
-    private runCommandStreaming;
-    private isMissingCommandError;
-    /**
-     * Run individual quality check by name
-     */
-    runSingleCheck(checkName: string, workingDirectory: string): Promise<{
-        passed: boolean;
-        output: string;
-    }>;
-    /**
-     * Get quality pipeline configuration
-     */
-    getConfig(): {
-        checks: never[];
-        parallel: boolean;
-    };
-}
-export {};