vibeman 0.0.1 → 0.0.3

package/dist/runtime/api/lib/local-config.js

@@ -0,0 +1,288 @@
+/**
+ * Local Configuration Manager
+ * Handles machine-specific configuration that should not be committed to git
+ */
+import { EventEmitter } from 'events';
+import fs from 'fs/promises';
+import path from 'path';
+import { z } from 'zod';
+import { log } from './logger.js';
+import { getProjectRoot } from './server/project-root.js';
+// Schema for local configuration
+const LocalConfigSchema = z.object({
+    providers: z
+        .object({
+        'claude-code': z
+            .object({
+            binPath: z.string().optional(),
+            detectedPath: z.string().optional(),
+            lastDetected: z.string().optional(), // ISO date
+            detectionMethod: z.enum(['explicit', 'PATH', 'common-location']).optional(),
+        })
+            .optional(),
+        codex: z
+            .object({
+            binPath: z.string().optional(),
+            detectedPath: z.string().optional(),
+            lastDetected: z.string().optional(),
+            detectionMethod: z.enum(['explicit', 'PATH', 'common-location']).optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    cache: z
+        .object({
+        lastProviderValidation: z.string().optional(), // ISO date
+        validationResults: z
+            .record(z.object({
+            available: z.boolean(),
+            error: z.string().optional(),
+            version: z.string().optional(),
+            checkedAt: z.string(), // ISO date
+        }))
+            .optional(),
+    })
+        .optional(),
+});
+// Default local configuration
+const DEFAULT_LOCAL_CONFIG = {
+    providers: {},
+    cache: {},
+};
+/**
+ * Local Configuration Service
+ * Manages machine-specific configuration stored in local-only directory
+ */
+export class LocalConfigService extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.config = { ...DEFAULT_LOCAL_CONFIG };
+        this.initialized = false;
+        const configDir = options.configDir ?? '.vibeman/.local';
+        const configFileName = options.configFileName ?? 'local-config.json';
+        // Store in project-local directory that should be gitignored
+        const projectRoot = getProjectRoot();
+        this.configPath = path.join(projectRoot, configDir, configFileName);
+    }
+    /**
+     * Initialize the local config service
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            await this.ensureConfigDirectory();
+            await this.loadConfig();
+            this.initialized = true;
+            log.info('Local config service initialized', { configPath: this.configPath }, 'local-config');
+        }
+        catch (error) {
+            log.error('Failed to initialize local config service', error, 'local-config');
+            throw error;
+        }
+    }
+    /**
+     * Get the full local configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get provider-specific configuration
+     */
+    getProviderConfig(provider) {
+        return this.config.providers?.[provider];
+    }
+    /**
+     * Set provider binary path and detection info
+     */
+    async setProviderPath(provider, binPath, detectionMethod = 'explicit') {
+        if (!this.config.providers) {
+            this.config.providers = {};
+        }
+        if (!this.config.providers[provider]) {
+            this.config.providers[provider] = {};
+        }
+        this.config.providers[provider].binPath = binPath;
+        this.config.providers[provider].detectedPath = binPath;
+        this.config.providers[provider].lastDetected = new Date().toISOString();
+        this.config.providers[provider].detectionMethod = detectionMethod;
+        await this.saveConfig();
+        this.emit('providerPathChanged', { provider, binPath, detectionMethod });
+    }
+    async updateDetectedProvider(provider, detectedPath, detectionMethod = 'PATH') {
+        if (!this.config.providers) {
+            this.config.providers = {};
+        }
+        if (!this.config.providers[provider]) {
+            this.config.providers[provider] = {};
+        }
+        this.config.providers[provider].detectedPath = detectedPath;
+        this.config.providers[provider].lastDetected = new Date().toISOString();
+        this.config.providers[provider].detectionMethod = detectionMethod;
+        await this.saveConfig();
+        this.emit('providerPathDetected', { provider, detectedPath, detectionMethod });
+    }
+    /**
+     * Clear provider configuration
+     */
+    async clearProviderPath(provider) {
+        if (this.config.providers?.[provider]) {
+            delete this.config.providers[provider];
+            await this.saveConfig();
+            this.emit('providerPathCleared', { provider });
+        }
+    }
+    /**
+     * Cache provider validation results
+     */
+    async cacheValidationResult(provider, result) {
+        if (!this.config.cache) {
+            this.config.cache = {};
+        }
+        if (!this.config.cache.validationResults) {
+            this.config.cache.validationResults = {};
+        }
+        this.config.cache.validationResults[provider] = {
+            ...result,
+            checkedAt: new Date().toISOString(),
+        };
+        this.config.cache.lastProviderValidation = new Date().toISOString();
+        await this.saveConfig();
+    }
+    /**
+     * Get cached validation result
+     */
+    getCachedValidationResult(provider) {
+        return this.config.cache?.validationResults?.[provider];
+    }
+    /**
+     * Check if cached validation is still fresh (within last 5 minutes)
+     */
+    isCachedValidationFresh(provider) {
+        const cached = this.getCachedValidationResult(provider);
+        if (!cached)
+            return false;
+        const cacheAge = Date.now() - new Date(cached.checkedAt).getTime();
+        const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+        return cacheAge < CACHE_TTL;
+    }
+    /**
+     * Clear all cached validation results
+     */
+    async clearValidationCache() {
+        if (this.config.cache) {
+            this.config.cache.validationResults = {};
+            this.config.cache.lastProviderValidation = undefined;
+            await this.saveConfig();
+            this.emit('validationCacheCleared');
+        }
+    }
+    /**
+     * Get configuration file information
+     */
+    async getConfigInfo() {
+        const exists = await this.fileExists(this.configPath);
+        let size;
+        if (exists) {
+            try {
+                const stats = await fs.stat(this.configPath);
+                size = stats.size;
+            }
+            catch {
+                // Ignore errors getting file size
+            }
+        }
+        return { path: this.configPath, exists, size };
+    }
+    /**
+     * Export configuration for debugging/backup
+     */
+    async exportConfig() {
+        return JSON.stringify(this.config, null, 2);
+    }
+    /**
+     * Import configuration from JSON string
+     */
+    async importConfig(configJson) {
+        try {
+            const parsed = JSON.parse(configJson);
+            const validated = LocalConfigSchema.parse(parsed);
+            this.config = validated;
+            await this.saveConfig();
+            this.emit('configImported', this.config);
+        }
+        catch (error) {
+            throw new Error(`Invalid config format: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Private methods
+    async ensureConfigDirectory() {
+        const configDir = path.dirname(this.configPath);
+        try {
+            await fs.access(configDir);
+        }
+        catch {
+            await fs.mkdir(configDir, { recursive: true });
+            log.info('Created local config directory', { configDir }, 'local-config');
+            // Create .gitignore to ensure this directory is not committed
+            const gitignorePath = path.join(configDir, '.gitignore');
+            try {
+                await fs.writeFile(gitignorePath, '# Local configuration - do not commit\n*\n!.gitignore\n');
+            }
+            catch (error) {
+                log.warn('Failed to create .gitignore in local config directory', error, 'local-config');
+            }
+        }
+    }
+    async loadConfig() {
+        try {
+            await fs.access(this.configPath);
+            const data = await fs.readFile(this.configPath, 'utf-8');
+            const parsed = JSON.parse(data);
+            // Validate and use parsed config
+            const validated = LocalConfigSchema.parse(parsed);
+            this.config = this.mergeWithDefaults(validated);
+            log.debug('Local config loaded from file', { configPath: this.configPath }, 'local-config');
+        }
+        catch (error) {
+            log.debug('Local config file not found or invalid, using defaults', { error: String(error) }, 'local-config');
+            this.config = { ...DEFAULT_LOCAL_CONFIG };
+            await this.saveConfig();
+        }
+    }
+    async saveConfig() {
+        const data = JSON.stringify(this.config, null, 2);
+        await fs.writeFile(this.configPath, data, 'utf-8');
+        log.debug('Local config saved to file', { configPath: this.configPath }, 'local-config');
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    mergeWithDefaults(config) {
+        return {
+            ...DEFAULT_LOCAL_CONFIG,
+            ...config,
+            providers: {
+                ...DEFAULT_LOCAL_CONFIG.providers,
+                ...config.providers,
+            },
+            cache: {
+                ...DEFAULT_LOCAL_CONFIG.cache,
+                ...config.cache,
+            },
+        };
+    }
+}
+// Singleton instance
+let localConfigService = null;
+export function getLocalConfigService(config) {
+    localConfigService ?? (localConfigService = new LocalConfigService(config));
+    return localConfigService;
+}

package/dist/runtime/api/lib/provider-detection.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Enhanced Provider Detection Service
+ * Robust detection logic for AI provider CLI tools with multiple fallback strategies
+ */
+export interface DetectionResult {
+    found: boolean;
+    path?: string;
+    version?: string;
+    method?: 'explicit' | 'PATH' | 'common-location';
+    error?: string;
+}
+export interface ProviderInfo {
+    name: string;
+    command: string;
+    versionArgsList?: string[][];
+    versionRegex: RegExp;
+}
+/**
+ * Provider definitions for detection
+ */
+export declare const PROVIDER_DEFINITIONS: Record<string, ProviderInfo>;
+/**
+ * Enhanced Provider Detection Service
+ */
+export declare class ProviderDetectionService {
+    private localConfig;
+    constructor();
+    /**
+     * Detect a specific provider with all fallback strategies
+     */
+    detectProvider(providerId: string): Promise<DetectionResult>;
+    /**
+     * Detect all configured providers
+     */
+    detectAllProviders(): Promise<Record<string, DetectionResult>>;
+    /**
+     * Validate a specific binary path
+     */
+    validateBinaryPath(binPath: string, provider: ProviderInfo, method?: DetectionResult['method']): Promise<DetectionResult>;
+    /**
+     * Set explicit provider path and cache it
+     */
+    setProviderPath(providerId: string, binPath: string): Promise<DetectionResult>;
+    /**
+     * Clear cached provider configuration
+     */
+    clearProviderPath(providerId: string): Promise<void>;
+    /**
+     * Get cached detection results if still fresh
+     */
+    getCachedResult(providerId: string): Promise<DetectionResult | null>;
+    private checkExplicitConfig;
+    private checkSystemCommand;
+    private getVersion;
+    private resolveCommand;
+    private toLocalConfigKey;
+    private cacheDetectionResult;
+}
+export declare function getProviderDetectionService(): ProviderDetectionService;

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>;