vibeman 0.0.5 → 0.0.6

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,93 +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: {
-            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-            priority: "low" | "medium" | "high";
-            title: string;
-            content: string;
-            taskId: string;
-            executionId?: string | undefined;
-        };
-        output: {
-            readonly executionId: 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 {};

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

@@ -1,94 +0,0 @@
-import { z } from 'zod';
-import { on, EventEmitter } from 'events';
-import { publicProcedure } from '../trpc.js';
-import { ExecutionIdSchema, TaskIdSchema } from '../router-helpers.js';
-import { makeAssertTaskActive } from '../router-helpers.js';
-import { log } from '../../lib/logger.js';
-export function buildExecutionRoutes({ taskService, vibingOrchestrator }) {
-    const assertTaskActive = makeAssertTaskActive(taskService);
-    return {
-        executeTask: publicProcedure.input(TaskIdSchema).mutation(async ({ input }) => {
-            assertTaskActive(input.taskId);
-            const { executionId } = await vibingOrchestrator.executeTask(input.taskId);
-            return { executionId };
-        }),
-        stopTaskExecution: publicProcedure.input(ExecutionIdSchema).mutation(async ({ input }) => {
-            await vibingOrchestrator.stopExecution(input.executionId);
-            return { success: true };
-        }),
-        getTaskExecutionStatus: publicProcedure.input(ExecutionIdSchema).query(async ({ input }) => {
-            return vibingOrchestrator.getExecutionStatus(input.executionId);
-        }),
-        getTaskExecutionLogs: publicProcedure.input(ExecutionIdSchema).query(async ({ input }) => {
-            try {
-                const persistedLogs = await vibingOrchestrator.getPersistedExecutionLogs(input.executionId);
-                return { logs: persistedLogs.logs };
-            }
-            catch (error) {
-                log.error('Failed to get task execution logs', error);
-                const logs = vibingOrchestrator.getExecutionLogs(input.executionId);
-                const logEntries = logs.map((message, index) => ({
-                    timestamp: new Date().toISOString(),
-                    level: 'info',
-                    message,
-                    data: { index },
-                }));
-                return { logs: logEntries };
-            }
-        }),
-        getTaskExecutions: publicProcedure.input(TaskIdSchema).query(async ({ input }) => {
-            return vibingOrchestrator.getTaskExecutions(input.taskId);
-        }),
-        getTaskExecutionStats: publicProcedure.query(async () => {
-            return vibingOrchestrator.getExecutionStats();
-        }),
-        improveTask: publicProcedure
-            .input(z.object({
-            taskId: z.string(),
-            title: z.string(),
-            type: z.enum(['feature', 'bug', 'chore', 'refactor', 'test', 'doc']),
-            priority: z.enum(['low', 'medium', 'high']),
-            content: z.string(),
-            executionId: z.string().optional(),
-        }))
-            .mutation(async ({ input }) => {
-            assertTaskActive(input.taskId);
-            const { executionId } = await vibingOrchestrator.startTaskImprovement(input.taskId, {
-                title: input.title,
-                type: input.type,
-                priority: input.priority,
-                content: input.content,
-            }, { executionId: input.executionId });
-            return { executionId };
-        }),
-        onExecutionUpdate: publicProcedure
-            .input(z.object({ executionId: z.string() }))
-            .subscription(async function* (opts) {
-            const input = opts.input;
-            // Emit initial status if exists
-            const initial = vibingOrchestrator.getExecutionStatus(input.executionId);
-            if (initial) {
-                yield {
-                    executionId: initial.id,
-                    status: initial.status,
-                    logs: initial.logs,
-                    error: initial.error,
-                };
-            }
-            const proxy = new EventEmitter();
-            const handleUpdate = (update) => {
-                if (update.executionId === input.executionId)
-                    proxy.emit('data', update);
-            };
-            vibingOrchestrator.on('executionUpdated', handleUpdate);
-            try {
-                for await (const [payload] of on(proxy, 'data', { signal: opts.signal })) {
-                    yield payload;
-                }
-            }
-            finally {
-                vibingOrchestrator.off('executionUpdated', handleUpdate);
-            }
-        }),
-    };
-}

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

@@ -1,45 +0,0 @@
-import type { TaskService } from '../../tasks/task-service.js';
-import type { GitService } from '../../vcs/git-service.js';
-export declare function buildGitRoutes(taskService: TaskService, gitService: GitService): {
-    readonly getGitStatus: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: {
-            current: string;
-            staged: string[];
-            modified: string[];
-            untracked: string[];
-            ahead: number;
-            behind: number;
-        };
-        meta: object;
-    }>;
-    readonly createBranch: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            taskId: string;
-            baseBranch?: string | undefined;
-        };
-        output: import("../../vcs/git-service.js").BranchInfo;
-        meta: object;
-    }>;
-    readonly commitChanges: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            taskId: string;
-            message?: string | undefined;
-            files?: string[] | undefined;
-        };
-        output: import("../../vcs/git-service.js").CommitInfo;
-        meta: object;
-    }>;
-    readonly getCommitHistory: import("@trpc/server").TRPCQueryProcedure<{
-        input: {
-            maxCount?: number | undefined;
-        };
-        output: import("../../vcs/git-service.js").CommitInfo[];
-        meta: object;
-    }>;
-    readonly hasUncommittedChanges: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: boolean;
-        meta: object;
-    }>;
-};

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

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-import { publicProcedure } from '../trpc.js';
-import { makeAssertTaskActive } from '../router-helpers.js';
-export function buildGitRoutes(taskService, gitService) {
-    const assertTaskActive = makeAssertTaskActive(taskService);
-    return {
-        getGitStatus: publicProcedure.query(async () => {
-            return await gitService.getStatus();
-        }),
-        createBranch: publicProcedure
-            .input(z.object({ taskId: z.string(), baseBranch: z.string().optional() }))
-            .mutation(async ({ input }) => {
-            const task = assertTaskActive(input.taskId);
-            return await gitService.createBranch(task, input.baseBranch);
-        }),
-        commitChanges: publicProcedure
-            .input(z.object({
-            taskId: z.string(),
-            message: z.string().optional(),
-            files: z.array(z.string()).optional(),
-        }))
-            .mutation(async ({ input }) => {
-            const task = assertTaskActive(input.taskId);
-            return await gitService.commitChanges(task, input.message, input.files);
-        }),
-        getCommitHistory: publicProcedure
-            .input(z.object({ maxCount: z.number().optional() }))
-            .query(async ({ input }) => {
-            return await gitService.getCommitHistory(input.maxCount);
-        }),
-        hasUncommittedChanges: publicProcedure.query(async () => {
-            return await gitService.hasUncommittedChanges();
-        }),
-    };
-}