vibeman 0.0.0 → 0.0.2

package/dist/runtime/api/api/routers/provider-config.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Provider Configuration Router
+ * Handles provider detection and local configuration management
+ */
+/**
+ * Provider Configuration Router
+ */
+export declare function buildProviderConfigRoutes(): {
+    /**
+     * Detect all providers with current status
+     */
+    detectAllProviders: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, import("../../lib/provider-detection.js").DetectionResult>;
+        meta: object;
+    }>;
+    /**
+     * Detect specific provider
+     */
+    detectProvider: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            provider: string;
+        };
+        output: import("../../lib/provider-detection.js").DetectionResult;
+        meta: object;
+    }>;
+    /**
+     * Set explicit provider path
+     */
+    setProviderPath: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            path: string;
+            provider: string;
+        };
+        output: {
+            success: boolean;
+            result: import("../../lib/provider-detection.js").DetectionResult;
+        };
+        meta: object;
+    }>;
+    /**
+     * Clear provider path (reset to auto-detection)
+     */
+    clearProviderPath: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            provider: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get local configuration info
+     */
+    getLocalConfigInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            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;
+            };
+            path: string;
+            exists: boolean;
+            size?: number;
+        };
+        meta: object;
+    }>;
+    /**
+     * Clear validation cache (force re-detection)
+     */
+    clearValidationCache: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get provider detection diagnostics
+     */
+    getProviderDiagnostics: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            localConfigPath: string;
+            localConfigExists: boolean;
+            providers: {
+                provider: string;
+                detection: import("../../lib/provider-detection.js").DetectionResult;
+                localConfig: {
+                    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;
+                cached: {
+                    available: boolean;
+                    error: string | undefined;
+                    version: string | undefined;
+                    checkedAt: string;
+                    isFresh: boolean;
+                } | null;
+            }[];
+        };
+        meta: object;
+    }>;
+};
+/**
+ * Test-friendly plain handlers
+ */
+export declare function buildProviderConfigRouteHandlers(): {
+    readonly detectAllProviders: () => Promise<Record<string, import("../../lib/provider-detection.js").DetectionResult>>;
+    readonly detectProvider: (input: {
+        provider: string;
+    }) => Promise<import("../../lib/provider-detection.js").DetectionResult>;
+    readonly setProviderPath: (input: {
+        provider: string;
+        path: string;
+    }) => Promise<{
+        success: true;
+        result: import("../../lib/provider-detection.js").DetectionResult;
+    }>;
+    readonly clearProviderPath: (input: {
+        provider: string;
+    }) => Promise<{
+        success: true;
+    }>;
+    readonly getLocalConfigInfo: () => Promise<{
+        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;
+        };
+        path: string;
+        exists: boolean;
+        size?: number;
+    }>;
+    readonly clearValidationCache: () => Promise<{
+        success: true;
+    }>;
+};

package/dist/runtime/api/api/routers/provider-config.js

@@ -0,0 +1,252 @@
+/**
+ * Provider Configuration Router
+ * Handles provider detection and local configuration management
+ */
+import { z } from 'zod';
+import { publicProcedure } from '../trpc.js';
+import { getProviderDetectionService } from '../../lib/provider-detection.js';
+import { getLocalConfigService } from '../../lib/local-config.js';
+import { log } from '../../lib/logger.js';
+/**
+ * Input schemas for API endpoints
+ */
+const DetectProviderInputSchema = z.object({
+    provider: z.string(),
+});
+const SetProviderPathInputSchema = z.object({
+    provider: z.string(),
+    path: z.string().trim().min(1, 'Path is required'),
+});
+const ClearProviderPathInputSchema = z.object({
+    provider: z.string(),
+});
+/**
+ * Provider Configuration Router
+ */
+export function buildProviderConfigRoutes() {
+    return {
+        /**
+         * Detect all providers with current status
+         */
+        detectAllProviders: publicProcedure.query(async () => {
+            try {
+                const detectionService = getProviderDetectionService();
+                const results = await detectionService.detectAllProviders();
+                log.debug('Detected all providers', { results }, 'provider-config');
+                return results;
+            }
+            catch (error) {
+                const msg = `Failed to detect providers: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Detect specific provider
+         */
+        detectProvider: publicProcedure.input(DetectProviderInputSchema).query(async ({ input }) => {
+            try {
+                const detectionService = getProviderDetectionService();
+                const result = await detectionService.detectProvider(input.provider);
+                log.debug('Detected provider', { provider: input.provider, result }, 'provider-config');
+                return result;
+            }
+            catch (error) {
+                const msg = `Failed to detect provider ${input.provider}: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Set explicit provider path
+         */
+        setProviderPath: publicProcedure
+            .input(SetProviderPathInputSchema)
+            .mutation(async ({ input }) => {
+            try {
+                const detectionService = getProviderDetectionService();
+                const result = await detectionService.setProviderPath(input.provider, input.path);
+                if (!result.found) {
+                    throw new Error(result.error || 'Invalid provider path');
+                }
+                log.info('Set provider path', { provider: input.provider, path: input.path }, 'provider-config');
+                return { success: true, result };
+            }
+            catch (error) {
+                const msg = `Failed to set provider path: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Clear provider path (reset to auto-detection)
+         */
+        clearProviderPath: publicProcedure
+            .input(ClearProviderPathInputSchema)
+            .mutation(async ({ input }) => {
+            try {
+                const detectionService = getProviderDetectionService();
+                await detectionService.clearProviderPath(input.provider);
+                log.info('Cleared provider path', { provider: input.provider }, 'provider-config');
+                return { success: true };
+            }
+            catch (error) {
+                const msg = `Failed to clear provider path: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Get local configuration info
+         */
+        getLocalConfigInfo: publicProcedure.query(async () => {
+            try {
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                const info = await localConfig.getConfigInfo();
+                const config = localConfig.getConfig();
+                return {
+                    ...info,
+                    providers: config.providers || {},
+                };
+            }
+            catch (error) {
+                const msg = `Failed to get local config info: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Clear validation cache (force re-detection)
+         */
+        clearValidationCache: publicProcedure.mutation(async () => {
+            try {
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                await localConfig.clearValidationCache();
+                log.info('Cleared validation cache', undefined, 'provider-config');
+                return { success: true };
+            }
+            catch (error) {
+                const msg = `Failed to clear validation cache: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Get provider detection diagnostics
+         */
+        getProviderDiagnostics: publicProcedure.query(async () => {
+            try {
+                const detectionService = getProviderDetectionService();
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                const detectionResults = await detectionService.detectAllProviders();
+                const localConfigInfo = await localConfig.getConfigInfo();
+                const providerConfigs = localConfig.getConfig().providers || {};
+                const diagnostics = Object.entries(detectionResults).map(([provider, result]) => {
+                    const config = providerConfigs[provider];
+                    const cached = localConfig.getCachedValidationResult(provider);
+                    return {
+                        provider,
+                        detection: result,
+                        localConfig: config,
+                        cached: cached
+                            ? {
+                                available: cached.available,
+                                error: cached.error,
+                                version: cached.version,
+                                checkedAt: cached.checkedAt,
+                                isFresh: localConfig.isCachedValidationFresh(provider),
+                            }
+                            : null,
+                    };
+                });
+                return {
+                    localConfigPath: localConfigInfo.path,
+                    localConfigExists: localConfigInfo.exists,
+                    providers: diagnostics,
+                };
+            }
+            catch (error) {
+                const msg = `Failed to get provider diagnostics: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+    };
+}
+/**
+ * Test-friendly plain handlers
+ */
+export function buildProviderConfigRouteHandlers() {
+    return {
+        async detectAllProviders() {
+            try {
+                const detectionService = getProviderDetectionService();
+                return await detectionService.detectAllProviders();
+            }
+            catch (error) {
+                throw new Error(`Failed to detect providers: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async detectProvider(input) {
+            try {
+                const detectionService = getProviderDetectionService();
+                return await detectionService.detectProvider(input.provider);
+            }
+            catch (error) {
+                throw new Error(`Failed to detect provider ${input.provider}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async setProviderPath(input) {
+            try {
+                const detectionService = getProviderDetectionService();
+                const result = await detectionService.setProviderPath(input.provider, input.path);
+                if (!result.found) {
+                    throw new Error(result.error || 'Invalid provider path');
+                }
+                return { success: true, result };
+            }
+            catch (error) {
+                throw new Error(`Failed to set provider path: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async clearProviderPath(input) {
+            try {
+                const detectionService = getProviderDetectionService();
+                await detectionService.clearProviderPath(input.provider);
+                return { success: true };
+            }
+            catch (error) {
+                throw new Error(`Failed to clear provider path: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async getLocalConfigInfo() {
+            try {
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                const info = await localConfig.getConfigInfo();
+                const config = localConfig.getConfig();
+                return {
+                    ...info,
+                    providers: config.providers || {},
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get local config info: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async clearValidationCache() {
+            try {
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                await localConfig.clearValidationCache();
+                return { success: true };
+            }
+            catch (error) {
+                throw new Error(`Failed to clear validation cache: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+    };
+}

package/dist/runtime/api/api/routers/settings.d.ts

@@ -0,0 +1,139 @@
+/**
+ * tRPC routes for settings management
+ */
+export declare function buildSettingsRoutes(): {
+    /**
+     * Get current settings
+     */
+    getSettings: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../../types/settings.js").VibemanSettings;
+        meta: object;
+    }>;
+    /**
+     * Detect quality checks using AI and persist them into settings
+     */
+    detectQualityChecks: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            checks: {
+                name: string;
+                command: string;
+                args: string[];
+                timeout: number;
+                enabled: boolean;
+            }[];
+            workingDirectory: string;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get a specific setting by path
+     */
+    getSetting: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            path: string[];
+        };
+        output: unknown;
+        meta: object;
+    }>;
+    /**
+     * Update multiple settings
+     */
+    updateSettings: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            path: string[];
+            value?: unknown;
+        }[];
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    /**
+     * Reset settings to defaults
+     */
+    resetToDefaults: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: import("../../types/settings.js").VibemanSettings;
+        meta: object;
+    }>;
+    /**
+     * Validate settings schema
+     */
+    validateSettings: import("@trpc/server").TRPCQueryProcedure<{
+        input: Record<string, unknown>;
+        output: {
+            valid: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    /**
+     * Get settings file information
+     */
+    getSettingsInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            path: string;
+            exists: boolean;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get available editor presets
+     */
+    getEditorPresets: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, Partial<{
+            type?: "vscode" | "cursor" | "vim" | "custom";
+            command?: string;
+            args?: string[];
+            name?: string;
+            openFileCommand?: string[];
+            openFolderCommand?: string[];
+        } | undefined>>;
+        meta: object;
+    }>;
+    /**
+     * Get available terminal presets
+     */
+    getTerminalPresets: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, Partial<{
+            type?: "system" | "iterm2" | "warp" | "custom";
+            command?: string;
+            args?: string[];
+            name?: string;
+            openCommand?: string[];
+        } | undefined>>;
+        meta: object;
+    }>;
+    /**
+     * Apply editor preset configuration
+     */
+    applyEditorPreset: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            presetName: string;
+        };
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    /**
+     * Apply terminal preset configuration
+     */
+    applyTerminalPreset: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            presetName: string;
+        };
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+};

package/dist/runtime/api/api/routers/settings.js

@@ -0,0 +1,113 @@
+/**
+ * tRPC routes for settings management
+ */
+import { z } from 'zod';
+import { publicProcedure } from '../trpc.js';
+import { getSettingsService } from '../../settings-service.js';
+import { QualityPipeline } from '../../workflows/quality-pipeline.js';
+import { getProjectRoot } from '../../lib/server/project-root.js';
+// Input validation schemas
+const UpdateSettingsInputSchema = z.array(z.object({
+    path: z.array(z.string().min(1)),
+    value: z.unknown(),
+}));
+export function buildSettingsRoutes() {
+    const settingsService = getSettingsService();
+    // Initialize settings service on first router build
+    settingsService.initialize().catch(console.error);
+    return {
+        /**
+         * Get current settings
+         */
+        getSettings: publicProcedure.query(async () => {
+            await settingsService.initialize();
+            return settingsService.getSettings();
+        }),
+        /**
+         * Detect quality checks using AI and persist them into settings
+         */
+        detectQualityChecks: publicProcedure.mutation(async () => {
+            // TODO: Integrate this into the onboarding flow to auto-bootstrap
+            // quality checks on first project setup.
+            await settingsService.initialize();
+            const pipeline = new QualityPipeline();
+            const workingDirectory = getProjectRoot();
+            const checks = await pipeline.detectAndPersistChecks(workingDirectory);
+            return { checks, workingDirectory };
+        }),
+        /**
+         * Get a specific setting by path
+         */
+        getSetting: publicProcedure
+            .input(z.object({ path: z.array(z.string().min(1)) }))
+            .query(async ({ input }) => {
+            await settingsService.initialize();
+            return settingsService.getSetting(input.path);
+        }),
+        /**
+         * Update multiple settings
+         */
+        updateSettings: publicProcedure.input(UpdateSettingsInputSchema).mutation(async ({ input }) => {
+            await settingsService.initialize();
+            const updates = input.map((item) => ({
+                path: item.path,
+                value: item.value,
+            }));
+            return await settingsService.updateSettings(updates);
+        }),
+        /**
+         * Reset settings to defaults
+         */
+        resetToDefaults: publicProcedure.mutation(async () => {
+            await settingsService.initialize();
+            await settingsService.resetToDefaults();
+            return settingsService.getSettings();
+        }),
+        /**
+         * Validate settings schema
+         */
+        validateSettings: publicProcedure.input(z.record(z.unknown())).query(async ({ input }) => {
+            await settingsService.initialize();
+            return settingsService.validateSettings(input);
+        }),
+        /**
+         * Get settings file information
+         */
+        getSettingsInfo: publicProcedure.query(async () => {
+            await settingsService.initialize();
+            return settingsService.getSettingsInfo();
+        }),
+        /**
+         * Get available editor presets
+         */
+        getEditorPresets: publicProcedure.query(async () => {
+            await settingsService.initialize();
+            return settingsService.getEditorPresets();
+        }),
+        /**
+         * Get available terminal presets
+         */
+        getTerminalPresets: publicProcedure.query(async () => {
+            await settingsService.initialize();
+            return settingsService.getTerminalPresets();
+        }),
+        /**
+         * Apply editor preset configuration
+         */
+        applyEditorPreset: publicProcedure
+            .input(z.object({ presetName: z.string().min(1) }))
+            .mutation(async ({ input }) => {
+            await settingsService.initialize();
+            return await settingsService.applyEditorPreset(input.presetName);
+        }),
+        /**
+         * Apply terminal preset configuration
+         */
+        applyTerminalPreset: publicProcedure
+            .input(z.object({ presetName: z.string().min(1) }))
+            .mutation(async ({ input }) => {
+            await settingsService.initialize();
+            return await settingsService.applyTerminalPreset(input.presetName);
+        }),
+    };
+}