vibeman 0.0.1 → 0.0.2

package/dist/runtime/api/lib/local-config.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Local Configuration Manager
+ * Handles machine-specific configuration that should not be committed to git
+ */
+import { EventEmitter } from 'events';
+import { z } from 'zod';
+declare const LocalConfigSchema: z.ZodObject<{
+    providers: z.ZodOptional<z.ZodObject<{
+        'claude-code': z.ZodOptional<z.ZodObject<{
+            binPath: z.ZodOptional<z.ZodString>;
+            detectedPath: z.ZodOptional<z.ZodString>;
+            lastDetected: z.ZodOptional<z.ZodString>;
+            detectionMethod: z.ZodOptional<z.ZodEnum<["explicit", "PATH", "common-location"]>>;
+        }, "strip", z.ZodTypeAny, {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        }, {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        }>>;
+        codex: z.ZodOptional<z.ZodObject<{
+            binPath: z.ZodOptional<z.ZodString>;
+            detectedPath: z.ZodOptional<z.ZodString>;
+            lastDetected: z.ZodOptional<z.ZodString>;
+            detectionMethod: z.ZodOptional<z.ZodEnum<["explicit", "PATH", "common-location"]>>;
+        }, "strip", z.ZodTypeAny, {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        }, {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        'claude-code'?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+        codex?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+    }, {
+        'claude-code'?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+        codex?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+    }>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        lastProviderValidation: z.ZodOptional<z.ZodString>;
+        validationResults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            available: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            checkedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        lastProviderValidation?: string | undefined;
+        validationResults?: Record<string, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }> | undefined;
+    }, {
+        lastProviderValidation?: string | undefined;
+        validationResults?: Record<string, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    providers?: {
+        'claude-code'?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+        codex?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+    } | undefined;
+    cache?: {
+        lastProviderValidation?: string | undefined;
+        validationResults?: Record<string, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }> | undefined;
+    } | undefined;
+}, {
+    providers?: {
+        'claude-code'?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+        codex?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+    } | undefined;
+    cache?: {
+        lastProviderValidation?: string | undefined;
+        validationResults?: Record<string, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }> | undefined;
+    } | undefined;
+}>;
+export type LocalConfig = z.infer<typeof LocalConfigSchema>;
+export interface LocalConfigServiceConfig {
+    configDir?: string;
+    configFileName?: string;
+}
+/**
+ * Local Configuration Service
+ * Manages machine-specific configuration stored in local-only directory
+ */
+export declare class LocalConfigService extends EventEmitter {
+    private config;
+    private configPath;
+    private initialized;
+    constructor(options?: LocalConfigServiceConfig);
+    /**
+     * Initialize the local config service
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the full local configuration
+     */
+    getConfig(): LocalConfig;
+    /**
+     * Get provider-specific configuration
+     */
+    getProviderConfig(provider: 'claude-code' | 'codex'): {
+        binPath?: string | undefined;
+        detectedPath?: string | undefined;
+        lastDetected?: string | undefined;
+        detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+    } | {
+        binPath?: string | undefined;
+        detectedPath?: string | undefined;
+        lastDetected?: string | undefined;
+        detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+    } | undefined;
+    /**
+     * Set provider binary path and detection info
+     */
+    setProviderPath(provider: 'claude-code' | 'codex', binPath: string, detectionMethod?: 'explicit' | 'PATH' | 'common-location'): Promise<void>;
+    updateDetectedProvider(provider: 'claude-code' | 'codex', detectedPath: string, detectionMethod?: 'PATH' | 'common-location'): Promise<void>;
+    /**
+     * Clear provider configuration
+     */
+    clearProviderPath(provider: 'claude-code' | 'codex'): Promise<void>;
+    /**
+     * Cache provider validation results
+     */
+    cacheValidationResult(provider: string, result: {
+        available: boolean;
+        error?: string;
+        version?: string;
+    }): Promise<void>;
+    /**
+     * Get cached validation result
+     */
+    getCachedValidationResult(provider: string): {
+        available: boolean;
+        error?: string;
+        version?: string;
+        checkedAt: string;
+    } | undefined;
+    /**
+     * Check if cached validation is still fresh (within last 5 minutes)
+     */
+    isCachedValidationFresh(provider: string): boolean;
+    /**
+     * Clear all cached validation results
+     */
+    clearValidationCache(): Promise<void>;
+    /**
+     * Get configuration file information
+     */
+    getConfigInfo(): Promise<{
+        path: string;
+        exists: boolean;
+        size?: number;
+    }>;
+    /**
+     * Export configuration for debugging/backup
+     */
+    exportConfig(): Promise<string>;
+    /**
+     * Import configuration from JSON string
+     */
+    importConfig(configJson: string): Promise<void>;
+    private ensureConfigDirectory;
+    private loadConfig;
+    private saveConfig;
+    private fileExists;
+    private mergeWithDefaults;
+}
+export declare function getLocalConfigService(config?: LocalConfigServiceConfig): LocalConfigService;
+export {};

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;