vibeman 0.0.3 → 0.0.6

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

@@ -1,200 +0,0 @@
-/**
- * AI Router - Multi-Model Orchestration API
- * Provides tRPC endpoints for managing AI providers and routing policies
- */
-import type { AgentService } from '../../agent/agent-service.js';
-import { type RoutingPolicy, type RoutableOperation } from '../../agent/routing-policy.js';
-/**
- * Build AI router with required dependencies
- */
-export declare function buildAIRoutes(options: {
-    agentService: AgentService;
-}): {
-    /**
-     * List all registered AI providers with health status
-     */
-    listProviders: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: {
-            name: string;
-            displayName: string;
-            available: boolean;
-            error: string | undefined;
-            capabilities: import("../../agent/ai-providers/types.js").ProviderCapabilities;
-            models: import("../../agent/ai-providers/types.js").ModelInfo[];
-        }[];
-        meta: object;
-    }>;
-    /**
-     * List available models from providers
-     */
-    listModels: import("@trpc/server").TRPCQueryProcedure<{
-        input: {
-            provider?: string | undefined;
-        } | undefined;
-        output: import("../../agent/ai-providers/types.js").ModelInfo[];
-        meta: object;
-    }>;
-    /**
-     * Get current routing policy
-     */
-    getRoutingPolicy: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: {
-            defaultProvider: string;
-            operations?: Partial<Record<"execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview", {
-                provider: string;
-                options?: {
-                    temperature?: number | undefined;
-                    maxTokens?: number | undefined;
-                    tools?: string[] | undefined;
-                } | undefined;
-                model?: string | undefined;
-                fallback?: string[] | undefined;
-            }>> | undefined;
-        };
-        meta: object;
-    }>;
-    /**
-     * Update routing policy
-     */
-    updateRoutingPolicy: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            policy: {
-                defaultProvider?: string | undefined;
-                operations?: Partial<Record<"execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview", {
-                    provider: string;
-                    options?: {
-                        temperature?: number | undefined;
-                        maxTokens?: number | undefined;
-                        tools?: string[] | undefined;
-                    } | undefined;
-                    model?: string | undefined;
-                    fallback?: string[] | undefined;
-                }>> | undefined;
-            };
-        };
-        output: {
-            success: boolean;
-            policy: any;
-        };
-        meta: object;
-    }>;
-    /**
-     * Set default provider
-     */
-    setDefaultProvider: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            provider: string;
-        };
-        output: {
-            success: boolean;
-            provider: string;
-        };
-        meta: object;
-    }>;
-    /**
-     * Set operation-specific configuration
-     */
-    setOperationConfig: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            operation: "execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview";
-            config: {
-                provider: string;
-                options?: {
-                    temperature?: number | undefined;
-                    maxTokens?: number | undefined;
-                    tools?: string[] | undefined;
-                } | undefined;
-                model?: string | undefined;
-                fallback?: string[] | undefined;
-            };
-        };
-        output: {
-            success: boolean;
-        };
-        meta: object;
-    }>;
-    /**
-     * Validate provider setup and refresh health status
-     */
-    validateProviders: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            force?: boolean | undefined;
-        } | undefined;
-        output: {
-            success: boolean;
-            results: {
-                provider: string;
-                available: boolean;
-                error: string | undefined;
-                modelCount: number;
-                capabilities: import("../../agent/ai-providers/types.js").ProviderCapabilities;
-            }[];
-            totalProviders: number;
-            availableProviders: number;
-        };
-        meta: object;
-    }>;
-};
-/**
- * Test-friendly plain handlers mirroring the AI routes, without tRPC wrappers.
- * Useful for unit tests that call functions directly.
- */
-export declare function buildAIRouteHandlers(options: {
-    agentService: AgentService;
-}): {
-    readonly listProviders: () => Promise<{
-        name: string;
-        displayName: any;
-        available: boolean;
-        error: string | undefined;
-        capabilities: any;
-        models: import("../../agent/ai-providers/types.js").ModelInfo[];
-    }[]>;
-    readonly listModels: (input?: {
-        provider?: string;
-    }) => Promise<any>;
-    readonly getRoutingPolicy: () => Promise<any>;
-    readonly updateRoutingPolicy: (input: {
-        policy: Partial<RoutingPolicy>;
-    }) => Promise<{
-        readonly success: true;
-        readonly policy: any;
-    }>;
-    readonly setDefaultProvider: (input: {
-        provider: string;
-    }) => Promise<{
-        readonly success: true;
-        readonly provider: string;
-    }>;
-    readonly setOperationConfig: (input: {
-        operation: RoutableOperation;
-        config: any;
-    }) => Promise<{
-        readonly success: true;
-    }>;
-    readonly validateProviders: () => Promise<{
-        success: true;
-        results: {
-            provider: string;
-            available: boolean;
-            error: string | undefined;
-            modelCount: number;
-            capabilities: import("../../agent/ai-providers/types.js").ProviderCapabilities;
-        }[];
-        totalProviders: number;
-        availableProviders: number;
-    }>;
-    readonly getProviderHealth: () => Promise<{
-        totalProviders: number;
-        availableProviders: number;
-        unavailableProviders: number;
-        providers: Array<{
-            name: string;
-            available: boolean;
-            error?: string;
-            modelCount: number;
-        }>;
-    }>;
-};

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

@@ -1,396 +0,0 @@
-/**
- * AI Router - Multi-Model Orchestration API
- * Provides tRPC endpoints for managing AI providers and routing policies
- */
-import { z } from 'zod';
-import { publicProcedure } from '../trpc.js';
-import { RoutingPolicySchema, OperationConfigSchema, } from '../../agent/routing-policy.js';
-import { log } from '../../lib/logger.js';
-import { getSettingsService } from '../../settings-service.js';
-/**
- * Input schemas for API endpoints
- */
-const ListModelsInputSchema = z.object({
-    provider: z.string().optional(),
-});
-const UpdateRoutingPolicyInputSchema = z.object({
-    policy: RoutingPolicySchema.partial(),
-});
-const SetDefaultProviderInputSchema = z.object({
-    provider: z.string(),
-});
-const SetOperationConfigInputSchema = z.object({
-    operation: z.enum(['execute_task', 'quality_checks', 'ai_codereview', 'ai_merge', 'improve_task']),
-    config: OperationConfigSchema,
-});
-const ValidateProvidersInputSchema = z.object({
-    force: z.boolean().optional(),
-});
-/**
- * Build AI router with required dependencies
- */
-export function buildAIRoutes(options) {
-    const { agentService } = options;
-    return {
-        /**
-         * List all registered AI providers with health status
-         */
-        listProviders: publicProcedure.query(async () => {
-            try {
-                const providers = agentService.getAvailableProviders();
-                const providerStatuses = await agentService.validateProviders();
-                const result = Array.from(providers.entries()).map(([name, provider]) => {
-                    const status = providerStatuses.get(name);
-                    return {
-                        name,
-                        displayName: provider.displayName,
-                        available: status?.available || false,
-                        error: status?.error,
-                        capabilities: status?.capabilities || provider.getCapabilities(),
-                        models: status?.models || [],
-                    };
-                });
-                log.debug('Listed AI providers', { count: result.length }, 'ai-router');
-                return result;
-            }
-            catch (error) {
-                const msg = `Failed to list providers: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'ai-router');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * List available models from providers
-         */
-        listModels: publicProcedure.input(ListModelsInputSchema.optional()).query(async ({ input }) => {
-            try {
-                if (input?.provider) {
-                    // Get models from specific provider
-                    const provider = agentService.getAvailableProviders().get(input.provider);
-                    if (!provider) {
-                        throw new Error(`Provider ${input.provider} not found`);
-                    }
-                    const models = await provider.detectAvailableModels();
-                    log.debug('Listed models for provider', { provider: input.provider, count: models.length }, 'ai-router');
-                    return models;
-                }
-                else {
-                    // Get models from all providers
-                    const models = await agentService.getAvailableModels();
-                    log.debug('Listed all available models', { count: models.length }, 'ai-router');
-                    return models;
-                }
-            }
-            catch (error) {
-                const msg = `Failed to list models: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'ai-router');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Get current routing policy
-         */
-        getRoutingPolicy: publicProcedure.query(async () => {
-            try {
-                const rpm = agentService.getRoutingPolicyManager?.();
-                if (!rpm) {
-                    const settings = getSettingsService().getSettings();
-                    return {
-                        defaultProvider: settings.agents.defaultProvider || 'claude-code',
-                        operations: {},
-                    };
-                }
-                const policy = (rpm.getEffectivePolicy
-                    ? await rpm.getEffectivePolicy()
-                    : await rpm.getPolicy());
-                log.debug('Retrieved routing policy', { policy }, 'ai-router');
-                return policy;
-            }
-            catch (error) {
-                const msg = `Failed to get routing policy: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'ai-router');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Update routing policy
-         */
-        updateRoutingPolicy: publicProcedure
-            .input(UpdateRoutingPolicyInputSchema)
-            .mutation(async ({ input }) => {
-            try {
-                const routingManager = agentService.getRoutingPolicyManager();
-                if (!routingManager) {
-                    throw new Error('Routing policy manager not available');
-                }
-                await routingManager.updatePolicy(input.policy);
-                const updatedPolicy = await routingManager.getPolicy();
-                log.info('Updated routing policy', { updates: input.policy }, 'ai-router');
-                return { success: true, policy: updatedPolicy };
-            }
-            catch (error) {
-                const msg = `Failed to update routing policy: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'ai-router');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Set default provider
-         */
-        setDefaultProvider: publicProcedure
-            .input(SetDefaultProviderInputSchema)
-            .mutation(async ({ input }) => {
-            try {
-                const routingManager = agentService.getRoutingPolicyManager();
-                if (!routingManager) {
-                    throw new Error('Routing policy manager not available');
-                }
-                // Validate provider exists
-                const providers = agentService.getAvailableProviders();
-                if (!providers.has(input.provider)) {
-                    throw new Error(`Provider ${input.provider} not found`);
-                }
-                await routingManager.setDefaultProvider(input.provider);
-                log.info('Set default provider', { provider: input.provider }, 'ai-router');
-                return { success: true, provider: input.provider };
-            }
-            catch (error) {
-                const msg = `Failed to set default provider: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'ai-router');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Set operation-specific configuration
-         */
-        setOperationConfig: publicProcedure
-            .input(SetOperationConfigInputSchema)
-            .mutation(async ({ input }) => {
-            try {
-                const routingManager = agentService.getRoutingPolicyManager();
-                if (!routingManager) {
-                    throw new Error('Routing policy manager not available');
-                }
-                // Validate provider exists
-                const providers = agentService.getAvailableProviders();
-                if (!providers.has(input.config.provider)) {
-                    throw new Error(`Provider ${input.config.provider} not found`);
-                }
-                // Validate fallback providers if specified
-                if (input.config.fallback) {
-                    for (const fallbackProvider of input.config.fallback) {
-                        if (!providers.has(fallbackProvider)) {
-                            throw new Error(`Fallback provider ${fallbackProvider} not found`);
-                        }
-                    }
-                }
-                await routingManager.setOperationConfig(input.operation, input.config);
-                log.info('Set operation config', { operation: input.operation, config: input.config }, 'ai-router');
-                return { success: true };
-            }
-            catch (error) {
-                const msg = `Failed to set operation config: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'ai-router');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Validate provider setup and refresh health status
-         */
-        validateProviders: publicProcedure
-            .input(ValidateProvidersInputSchema.optional())
-            .mutation(async ({ input }) => {
-            try {
-                const results = await agentService.validateProviders();
-                const validation = Array.from(results.entries()).map(([name, status]) => ({
-                    provider: name,
-                    available: status.available,
-                    error: status.error,
-                    modelCount: status.models.length,
-                    capabilities: status.capabilities,
-                }));
-                log.info('Validated providers', {
-                    force: input?.force || false,
-                    results: validation,
-                }, 'ai-router');
-                return {
-                    success: true,
-                    results: validation,
-                    totalProviders: validation.length,
-                    availableProviders: validation.filter((p) => p.available).length,
-                };
-            }
-            catch (error) {
-                const msg = `Failed to validate providers: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'ai-router');
-                throw new Error(msg);
-            }
-        }),
-    };
-}
-/**
- * Test-friendly plain handlers mirroring the AI routes, without tRPC wrappers.
- * Useful for unit tests that call functions directly.
- */
-export function buildAIRouteHandlers(options) {
-    const { agentService } = options;
-    return {
-        async listProviders() {
-            try {
-                const providers = agentService.getAvailableProviders();
-                const providerStatuses = await agentService.validateProviders();
-                return Array.from(providers.entries()).map(([name, provider]) => {
-                    const status = providerStatuses.get(name);
-                    return {
-                        name,
-                        displayName: provider.displayName,
-                        available: status?.available || false,
-                        error: status?.error,
-                        capabilities: status?.capabilities || provider.getCapabilities?.(),
-                        models: status?.models || [],
-                    };
-                });
-            }
-            catch (error) {
-                throw new Error(`Failed to list providers: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async listModels(input) {
-            try {
-                if (input?.provider) {
-                    const provider = agentService.getAvailableProviders().get(input.provider);
-                    if (!provider)
-                        throw new Error(`Provider ${input.provider} not found`);
-                    return await provider.detectAvailableModels();
-                }
-                return await agentService.getAvailableModels();
-            }
-            catch (error) {
-                throw new Error(`Failed to list models: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async getRoutingPolicy() {
-            try {
-                const rpm = agentService.getRoutingPolicyManager?.() ||
-                    agentService.routingPolicyManager;
-                const policy = await rpm?.getPolicy();
-                if (!policy) {
-                    const settings = getSettingsService().getSettings();
-                    return {
-                        defaultProvider: settings.agents.defaultProvider || 'claude-code',
-                        operations: {},
-                    };
-                }
-                return policy;
-            }
-            catch (error) {
-                throw new Error(`Failed to get routing policy: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async updateRoutingPolicy(input) {
-            try {
-                const routingManager = agentService.getRoutingPolicyManager?.() ||
-                    agentService.routingPolicyManager;
-                if (!routingManager)
-                    throw new Error('Routing policy manager not available');
-                await routingManager.updatePolicy(input.policy);
-                const updatedPolicy = await routingManager.getPolicy();
-                return { success: true, policy: updatedPolicy };
-            }
-            catch (error) {
-                throw new Error(`Failed to update routing policy: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async setDefaultProvider(input) {
-            try {
-                const routingManager = agentService.getRoutingPolicyManager?.() ||
-                    agentService.routingPolicyManager;
-                if (!routingManager)
-                    throw new Error('Routing policy manager not available');
-                const providers = agentService.getAvailableProviders();
-                if (!providers.has(input.provider))
-                    throw new Error(`Provider ${input.provider} not found`);
-                await routingManager.setDefaultProvider(input.provider);
-                return { success: true, provider: input.provider };
-            }
-            catch (error) {
-                throw new Error(`Failed to set default provider: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async setOperationConfig(input) {
-            try {
-                const routingManager = agentService.getRoutingPolicyManager?.() ||
-                    agentService.routingPolicyManager;
-                if (!routingManager)
-                    throw new Error('Routing policy manager not available');
-                const providers = agentService.getAvailableProviders();
-                if (!providers.has(input.config.provider)) {
-                    throw new Error(`Provider ${input.config.provider} not found`);
-                }
-                if (input.config.fallback) {
-                    for (const fallbackProvider of input.config.fallback) {
-                        if (!providers.has(fallbackProvider)) {
-                            throw new Error(`Fallback provider ${fallbackProvider} not found`);
-                        }
-                    }
-                }
-                await routingManager.setOperationConfig(input.operation, input.config);
-                return { success: true };
-            }
-            catch (error) {
-                throw new Error(`Failed to set operation config: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async validateProviders() {
-            try {
-                const results = await agentService.validateProviders();
-                const validation = Array.from(results.entries()).map(([name, status]) => ({
-                    provider: name,
-                    available: status.available,
-                    error: status.error,
-                    modelCount: status.models.length,
-                    capabilities: status.capabilities,
-                }));
-                return {
-                    success: true,
-                    results: validation,
-                    totalProviders: validation.length,
-                    availableProviders: validation.filter((p) => p.available).length,
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to validate providers: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async getProviderHealth() {
-            try {
-                const providers = agentService.getAvailableProviders();
-                const statuses = await agentService.validateProviders();
-                const health = {
-                    totalProviders: providers.size,
-                    availableProviders: 0,
-                    unavailableProviders: 0,
-                    providers: [],
-                };
-                for (const [name] of providers) {
-                    const status = statuses.get(name);
-                    const isAvailable = status?.available || false;
-                    if (isAvailable)
-                        health.availableProviders++;
-                    else
-                        health.unavailableProviders++;
-                    health.providers.push({
-                        name,
-                        available: isAvailable,
-                        error: status?.error,
-                        modelCount: status?.models.length || 0,
-                    });
-                }
-                return health;
-            }
-            catch (error) {
-                throw new Error(`Failed to get provider health: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-    };
-}

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

@@ -1,98 +0,0 @@
-import type { TaskService } from '../../tasks/task-service.js';
-import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
-type Deps = {
-    taskService: TaskService;
-    vibingOrchestrator: VibingOrchestrator;
-};
-export declare function buildExecutionRoutes({ taskService, vibingOrchestrator }: Deps): {
-    readonly executeTask: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            taskId: string;
-        };
-        output: {
-            readonly executionId: string;
-        };
-        meta: object;
-    }>;
-    readonly stopTaskExecution: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            executionId: string;
-        };
-        output: {
-            readonly success: true;
-        };
-        meta: object;
-    }>;
-    readonly getTaskExecutionStatus: import("@trpc/server").TRPCQueryProcedure<{
-        input: {
-            executionId: string;
-        };
-        output: import("../../types/index.js").AgentExecution | null;
-        meta: object;
-    }>;
-    readonly getTaskExecutionLogs: import("@trpc/server").TRPCQueryProcedure<{
-        input: {
-            executionId: string;
-        };
-        output: {
-            logs: any[];
-        };
-        meta: object;
-    }>;
-    readonly getTaskExecutions: import("@trpc/server").TRPCQueryProcedure<{
-        input: {
-            taskId: string;
-        };
-        output: import("../../types/index.js").AgentExecution[];
-        meta: object;
-    }>;
-    readonly getTaskExecutionStats: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: {
-            total: number;
-            pending: number;
-            running: number;
-            completed: number;
-            failed: number;
-            cancelled: number;
-            worktrees: {
-                active: number;
-                total: number;
-                enabled: boolean;
-            };
-        };
-        meta: object;
-    }>;
-    readonly improveTask: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            title: string;
-            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-            priority: "low" | "medium" | "high";
-            content: string;
-            taskId: string;
-            executionId?: string | undefined;
-        };
-        output: {
-            type: string;
-            priority: string;
-            content: string;
-            title?: string;
-            executionId: string;
-            selectedModel?: string;
-        };
-        meta: object;
-    }>;
-    readonly onExecutionUpdate: import("@trpc/server").TRPCSubscriptionProcedure<{
-        input: {
-            executionId: string;
-        };
-        output: AsyncIterable<{
-            executionId: string;
-            status: "pending" | "running" | "completed" | "failed" | "cancelled";
-            logs: string[];
-            error?: string;
-        }, void, any>;
-        meta: object;
-    }>;
-};
-export {};