vibeman 0.0.1 → 0.0.2

package/dist/runtime/api/lib/provider-detection.js

@@ -0,0 +1,244 @@
+/**
+ * Enhanced Provider Detection Service
+ * Robust detection logic for AI provider CLI tools with multiple fallback strategies
+ */
+import { exec, execFile } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import which from 'which';
+import { log } from './logger.js';
+import { getLocalConfigService } from './local-config.js';
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+/**
+ * Provider definitions for detection
+ */
+export const PROVIDER_DEFINITIONS = {
+    'claude-code': {
+        name: 'Claude Code',
+        command: 'claude',
+        versionArgsList: [['--version'], ['-v']],
+        versionRegex: /(\d+\.\d+\.\d+)/,
+    },
+    codex: {
+        name: 'Codex CLI',
+        command: 'codex',
+        versionArgsList: [['--version'], ['-v']],
+        versionRegex: /(\d+\.\d+\.\d+)/,
+    },
+};
+/**
+ * Enhanced Provider Detection Service
+ */
+export class ProviderDetectionService {
+    constructor() {
+        this.localConfig = getLocalConfigService();
+        // Ensure local config is initialized
+        this.localConfig.initialize().catch((error) => {
+            log.error('Failed to initialize local config for provider detection', error, 'provider-detection');
+        });
+    }
+    /**
+     * Detect a specific provider with all fallback strategies
+     */
+    async detectProvider(providerId) {
+        const provider = PROVIDER_DEFINITIONS[providerId];
+        if (!provider) {
+            return {
+                found: false,
+                error: `Unknown provider: ${providerId}`,
+            };
+        }
+        log.debug(`Detecting provider: ${provider.name}`, { providerId }, 'provider-detection');
+        // Strategy 1: Check explicit configuration from local config
+        const explicitResult = await this.checkExplicitConfig(providerId, provider);
+        if (explicitResult.found) {
+            log.info(`Provider found via explicit config: ${provider.name}`, explicitResult, 'provider-detection');
+            return explicitResult;
+        }
+        // Strategy 2: Resolve via system command lookup
+        const systemResult = await this.checkSystemCommand(provider);
+        if (systemResult.found) {
+            log.info(`Provider found on system PATH: ${provider.name}`, systemResult, 'provider-detection');
+            await this.cacheDetectionResult(providerId, systemResult);
+            return systemResult;
+        }
+        // All strategies failed
+        const result = {
+            found: false,
+            error: `${provider.name} not found via explicit config or system PATH`,
+        };
+        log.warn(`Provider not found: ${provider.name}`, result, 'provider-detection');
+        return result;
+    }
+    /**
+     * Detect all configured providers
+     */
+    async detectAllProviders() {
+        const results = {};
+        for (const providerId of Object.keys(PROVIDER_DEFINITIONS)) {
+            try {
+                results[providerId] = await this.detectProvider(providerId);
+            }
+            catch (error) {
+                results[providerId] = {
+                    found: false,
+                    error: `Detection failed: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        }
+        return results;
+    }
+    /**
+     * Validate a specific binary path
+     */
+    async validateBinaryPath(binPath, provider, method = 'explicit') {
+        try {
+            // Check if file exists and is executable
+            const stats = await fs.stat(binPath);
+            if (!stats.isFile()) {
+                return {
+                    found: false,
+                    error: `Path is not a file: ${binPath}`,
+                };
+            }
+            // Try to execute version command
+            const version = await this.getVersion(binPath, provider);
+            return {
+                found: true,
+                path: binPath,
+                version,
+                method,
+            };
+        }
+        catch (error) {
+            return {
+                found: false,
+                path: binPath,
+                error: `Validation failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Set explicit provider path and cache it
+     */
+    async setProviderPath(providerId, binPath) {
+        const provider = PROVIDER_DEFINITIONS[providerId];
+        if (!provider) {
+            return {
+                found: false,
+                error: `Unknown provider: ${providerId}`,
+            };
+        }
+        const result = await this.validateBinaryPath(binPath, provider);
+        if (result.found) {
+            const localId = this.toLocalConfigKey(providerId);
+            await this.localConfig.setProviderPath(localId, binPath, 'explicit');
+        }
+        return result;
+    }
+    /**
+     * Clear cached provider configuration
+     */
+    async clearProviderPath(providerId) {
+        const localId = this.toLocalConfigKey(providerId);
+        await this.localConfig.clearProviderPath(localId);
+    }
+    /**
+     * Get cached detection results if still fresh
+     */
+    async getCachedResult(providerId) {
+        if (this.localConfig.isCachedValidationFresh(providerId)) {
+            const cached = this.localConfig.getCachedValidationResult(providerId);
+            if (cached) {
+                const localId = this.toLocalConfigKey(providerId);
+                return {
+                    found: cached.available,
+                    path: cached.available
+                        ? this.localConfig.getProviderConfig(localId)?.detectedPath
+                        : undefined,
+                    version: cached.version,
+                    error: cached.error,
+                };
+            }
+        }
+        return null;
+    }
+    // Private detection strategies
+    async checkExplicitConfig(providerId, provider) {
+        const localId = this.toLocalConfigKey(providerId);
+        const config = this.localConfig.getProviderConfig(localId);
+        if (!config?.binPath) {
+            return { found: false };
+        }
+        return this.validateBinaryPath(config.binPath, provider, 'explicit');
+    }
+    async checkSystemCommand(provider) {
+        const resolvedPath = await this.resolveCommand(provider.command);
+        if (!resolvedPath) {
+            return { found: false };
+        }
+        return this.validateBinaryPath(resolvedPath, provider, 'PATH');
+    }
+    async getVersion(binPath, provider) {
+        const argSets = provider.versionArgsList ?? [['--version']];
+        for (const args of argSets) {
+            try {
+                const { stdout, stderr } = await execFileAsync(binPath, args, { timeout: 10000 });
+                const output = (stdout + stderr).trim();
+                const match = output.match(provider.versionRegex);
+                if (match?.[1]) {
+                    return match[1];
+                }
+            }
+            catch (error) {
+                log.debug(`Version command failed for ${binPath}`, { args, error }, 'provider-detection');
+            }
+        }
+        return undefined;
+    }
+    async resolveCommand(command) {
+        try {
+            return await which(command);
+        }
+        catch (error) {
+            log.debug(`which lookup failed for ${command}`, error, 'provider-detection');
+        }
+        if (process.platform !== 'win32') {
+            try {
+                const { stdout } = await execAsync(`command -v ${command}`, { timeout: 5000 });
+                const resolved = stdout.trim().split('\n')[0];
+                return resolved ? resolved : null;
+            }
+            catch (error) {
+                log.debug(`command -v lookup failed for ${command}`, error, 'provider-detection');
+            }
+        }
+        return null;
+    }
+    toLocalConfigKey(providerId) {
+        return providerId === 'claude-code' ? 'claude-code' : 'codex';
+    }
+    async cacheDetectionResult(providerId, result) {
+        if (result.found && result.path) {
+            const localId = this.toLocalConfigKey(providerId);
+            if (result.method === 'explicit') {
+                await this.localConfig.setProviderPath(localId, result.path, 'explicit');
+            }
+            else {
+                await this.localConfig.updateDetectedProvider(localId, result.path, result.method || 'PATH');
+            }
+        }
+        await this.localConfig.cacheValidationResult(providerId, {
+            available: result.found,
+            error: result.error,
+            version: result.version,
+        });
+    }
+}
+// Singleton instance
+let providerDetectionService = null;
+export function getProviderDetectionService() {
+    providerDetectionService ?? (providerDetectionService = new ProviderDetectionService());
+    return providerDetectionService;
+}

package/dist/runtime/api/lib/server/bootstrap.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Server Bootstrap - Async-first service initialization
+ *
+ * Provides ordered initialization of core services before router creation,
+ * ensuring all dependencies are ready for synchronous access during runtime.
+ */
+import { getSettingsService } from '../../settings-service.js';
+import { TaskService } from '../../tasks/task-service.js';
+import { AgentService } from '../../agent/agent-service.js';
+import { GitService } from '../../vcs/git-service.js';
+import { WorktreeService } from '../../vcs/worktree-service.js';
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+/**
+ * Initialize core services in proper dependency order.
+ * Must be called before any service getters or router creation.
+ */
+export declare function bootstrap(): Promise<void>;
+/**
+ * Ready-only sync getters - throw if called before bootstrap
+ */
+export declare function getBootstrappedSettingsService(): ReturnType<typeof getSettingsService>;
+export declare function getBootstrappedTaskService(): TaskService;
+export declare function getBootstrappedAgentService(): AgentService;
+export declare function getBootstrappedGitService(): GitService;
+export declare function getBootstrappedWorktreeService(): WorktreeService;
+export declare function getBootstrappedVibingOrchestrator(): VibingOrchestrator;
+/**
+ * Get bootstrap completion promise for diagnostics/tests
+ */
+export declare function getBootstrapReady(): Promise<void> | null;
+/**
+ * Check if bootstrap has completed
+ */
+export declare function isBootstrapComplete(): boolean;
+/**
+ * Test bootstrap function that initializes against a temp workspace
+ */
+export declare function testBootstrap(tempWorkspace?: string): Promise<void>;

package/dist/runtime/api/lib/server/bootstrap.js

@@ -0,0 +1,197 @@
+/**
+ * Server Bootstrap - Async-first service initialization
+ *
+ * Provides ordered initialization of core services before router creation,
+ * ensuring all dependencies are ready for synchronous access during runtime.
+ */
+import { log } from '../logger.js';
+import { getSettingsService } from '../../settings-service.js';
+import { TaskService } from '../../tasks/task-service.js';
+import { AgentService } from '../../agent/agent-service.js';
+import { GitService } from '../../vcs/git-service.js';
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+import { getProjectRoot, getVibeDir } from './project-root.js';
+// Ready-only service instances - throw if accessed before bootstrap
+let settingsService = null;
+let taskService = null;
+let agentService = null;
+let gitService = null;
+let worktreeService = null;
+let vibingOrchestrator = null;
+// Bootstrap completion promise for diagnostics/tests
+let ready = null;
+let isBootstrapped = false;
+// Default config fallback for VibingOrchestrator
+const getDefaultVibingConfig = () => ({
+    autoQualityChecks: true,
+    requireHumanApproval: true,
+    aiCodeReview: true,
+    retryPolicy: { maxImplementationAttempts: 3 },
+    autoCommit: false,
+});
+/**
+ * Initialize core services in proper dependency order.
+ * Must be called before any service getters or router creation.
+ */
+export async function bootstrap() {
+    if (isBootstrapped) {
+        log.info('Bootstrap already completed, skipping');
+        return;
+    }
+    if (ready) {
+        log.info('Bootstrap already in progress, waiting...');
+        return ready;
+    }
+    const startTime = Date.now();
+    log.info('Starting server bootstrap', {}, 'bootstrap');
+    ready = (async () => {
+        try {
+            // Stage 1: Settings Service (foundation)
+            const settingsStart = Date.now();
+            settingsService = getSettingsService();
+            log.info('Settings service initialized', {
+                duration: Date.now() - settingsStart,
+            }, 'bootstrap');
+            // Stage 2: Task Service (depends on settings for vibeDir)
+            const taskStart = Date.now();
+            const settingsVibeDir = (() => {
+                try {
+                    const s = settingsService.getSettings();
+                    return s?.development?.vibeDir;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            const vibeDir = settingsVibeDir ?? getVibeDir();
+            taskService = new TaskService(vibeDir);
+            await taskService.ensureInitialized();
+            log.info('Task service initialized', {
+                vibeDir,
+                duration: Date.now() - taskStart,
+            }, 'bootstrap');
+            // Stage 3: Git Service (independent)
+            const gitStart = Date.now();
+            const projectRoot = getProjectRoot();
+            const settingsDefaultBranch = (() => {
+                try {
+                    const s = settingsService.getSettings();
+                    return s?.development?.git?.defaultBranch;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            const gitConfig = {
+                defaultBranch: settingsDefaultBranch || 'main',
+            };
+            gitService = new GitService(projectRoot, gitConfig);
+            log.info('Git service initialized', {
+                projectRoot,
+                defaultBranch: gitConfig.defaultBranch,
+                duration: Date.now() - gitStart,
+            }, 'bootstrap');
+            // Stage 4: Agent Service (depends on task service)
+            const agentStart = Date.now();
+            agentService = new AgentService(taskService, projectRoot);
+            log.info('Agent service initialized', {
+                duration: Date.now() - agentStart,
+            }, 'bootstrap');
+            // Stage 5: Worktree Service (depends on git service, settings)
+            const worktreeStart = Date.now();
+            worktreeService = agentService.getWorktreeService();
+            await worktreeService.initialize();
+            log.info('Worktree service initialized', {
+                duration: Date.now() - worktreeStart,
+            }, 'bootstrap');
+            // Stage 6: VibingOrchestrator (depends on all previous services)
+            const orchestratorStart = Date.now();
+            vibingOrchestrator = new VibingOrchestrator(taskService, agentService, worktreeService, getDefaultVibingConfig(), gitService);
+            await vibingOrchestrator.initialize();
+            log.info('VibingOrchestrator initialized', {
+                duration: Date.now() - orchestratorStart,
+            }, 'bootstrap');
+            isBootstrapped = true;
+            const totalDuration = Date.now() - startTime;
+            log.info('Server bootstrap completed', {
+                totalDuration,
+                stages: 6,
+            }, 'bootstrap');
+        }
+        catch (error) {
+            log.error('Server bootstrap failed', error, 'bootstrap');
+            throw error;
+        }
+    })();
+    return ready;
+}
+/**
+ * Ready-only sync getters - throw if called before bootstrap
+ */
+export function getBootstrappedSettingsService() {
+    if (!settingsService) {
+        throw new Error('Settings service not available - bootstrap() must be called first');
+    }
+    return settingsService;
+}
+export function getBootstrappedTaskService() {
+    if (!taskService) {
+        throw new Error('Task service not available - bootstrap() must be called first');
+    }
+    return taskService;
+}
+export function getBootstrappedAgentService() {
+    if (!agentService) {
+        throw new Error('Agent service not available - bootstrap() must be called first');
+    }
+    return agentService;
+}
+export function getBootstrappedGitService() {
+    if (!gitService) {
+        throw new Error('Git service not available - bootstrap() must be called first');
+    }
+    return gitService;
+}
+export function getBootstrappedWorktreeService() {
+    if (!worktreeService) {
+        throw new Error('Worktree service not available - bootstrap() must be called first');
+    }
+    return worktreeService;
+}
+export function getBootstrappedVibingOrchestrator() {
+    if (!vibingOrchestrator) {
+        throw new Error('VibingOrchestrator not available - bootstrap() must be called first');
+    }
+    return vibingOrchestrator;
+}
+/**
+ * Get bootstrap completion promise for diagnostics/tests
+ */
+export function getBootstrapReady() {
+    return ready;
+}
+/**
+ * Check if bootstrap has completed
+ */
+export function isBootstrapComplete() {
+    return isBootstrapped;
+}
+/**
+ * Test bootstrap function that initializes against a temp workspace
+ */
+export async function testBootstrap(tempWorkspace) {
+    // Reset bootstrap state for testing
+    settingsService = null;
+    taskService = null;
+    agentService = null;
+    gitService = null;
+    worktreeService = null;
+    vibingOrchestrator = null;
+    ready = null;
+    isBootstrapped = false;
+    // TODO: Implement temp workspace logic if needed
+    if (tempWorkspace) {
+        log.info('Test bootstrap with temp workspace', { tempWorkspace }, 'bootstrap');
+    }
+    return bootstrap();
+}

package/dist/runtime/api/lib/server/project-root.js

@@ -8,7 +8,30 @@ import path from 'path';
 export function getProjectRoot() {
     const envRoot = process.env.VIBEMAN_PROJECT_ROOT;
     if (envRoot && envRoot.trim().length > 0) {
-        return path.resolve(envRoot);
+        const trimmedRoot = envRoot.trim();
+        if (path.isAbsolute(trimmedRoot)) {
+            return path.normalize(trimmedRoot);
+        }
+        const baseCandidates = [
+            process.env.VIBEMAN_PROJECT_ROOT_BASE,
+            process.env.INIT_CWD,
+            process.env.PWD,
+            process.cwd(),
+        ].filter((candidate) => !!candidate && candidate.trim().length > 0);
+        let fallbackResolved = null;
+        for (const base of baseCandidates) {
+            const resolved = path.resolve(base, trimmedRoot);
+            if (!fallbackResolved) {
+                fallbackResolved = resolved;
+            }
+            if (fs.existsSync(resolved)) {
+                return resolved;
+            }
+        }
+        if (fallbackResolved) {
+            return fallbackResolved;
+        }
+        return path.resolve(trimmedRoot);
     }
     // First preference: directory that contains a .git directory/file
     let dir = process.cwd();