vibeman 0.0.0 → 0.0.2

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

@@ -0,0 +1,395 @@
+/**
+ * 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', 'improve_task', 'ai_codereview', 'ai_merge']),
+    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 policy = await agentService.getRoutingPolicyManager()?.getPolicy();
+                if (!policy) {
+                    // Return default policy if none exists
+                    const settings = getSettingsService().getSettings();
+                    const defaultPolicy = {
+                        defaultProvider: settings.agents.defaultProvider || 'claude-code',
+                        operations: {},
+                    };
+                    return defaultPolicy;
+                }
+                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

@@ -0,0 +1,98 @@
+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: "high" | "medium" | "low";
+            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 {};

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

@@ -0,0 +1,94 @@
+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 improvement = await vibingOrchestrator.improveTaskContent(input.taskId, {
+                title: input.title,
+                type: input.type,
+                priority: input.priority,
+                content: input.content,
+            }, { executionId: input.executionId });
+            return improvement;
+        }),
+        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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,35 @@
+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();
+        }),
+    };
+}