vibeman 0.0.0 → 0.0.1

package/dist/runtime/api/agent/routing-policy.js

@@ -0,0 +1,246 @@
+/**
+ * AI Routing Policy Management
+ * Handles provider selection per operation with fallbacks and configuration
+ */
+import { z } from 'zod';
+import fs from 'fs/promises';
+import path from 'path';
+import { log } from '../lib/logger.js';
+import { getSettingsService } from '../settings-service.js';
+import { getVibeDir } from '../lib/server/project-root.js';
+/**
+ * Generation options for AI execution
+ */
+export const GenerationOptionsSchema = z.object({
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().positive().optional(),
+    tools: z.array(z.string()).optional(),
+});
+/**
+ * Per-operation routing configuration
+ */
+export const OperationConfigSchema = z.object({
+    provider: z.string(),
+    model: z.string().optional(),
+    options: GenerationOptionsSchema.optional(),
+    fallback: z.array(z.string()).optional(),
+});
+/**
+ * Complete routing policy schema
+ */
+export const RoutingPolicySchema = z.object({
+    defaultProvider: z.string(),
+    operations: z
+        .record(z.enum(['execute_task', 'improve_task', 'ai_codereview', 'ai_merge']), OperationConfigSchema)
+        .optional(),
+});
+/**
+ * Routing Policy Manager
+ * Manages AI provider routing policies with hot-reload capability
+ */
+export class RoutingPolicyManager {
+    constructor() {
+        this.policy = null;
+        this.lastModified = 0;
+        this.policyFilePath = path.join(getVibeDir(), 'ai-routing.json');
+    }
+    /**
+     * Get current effective policy with hot-reload
+     */
+    async getPolicy() {
+        await this.loadPolicyIfChanged();
+        // Return default policy if none exists
+        if (!this.policy) {
+            const settings = getSettingsService().getSettings();
+            return {
+                defaultProvider: settings.agents.defaultProvider || 'claude-code',
+                operations: {},
+            };
+        }
+        return this.policy;
+    }
+    /**
+     * Update routing policy and persist to disk
+     */
+    async updatePolicy(updates) {
+        const currentPolicy = await this.getPolicy();
+        const newPolicy = {
+            defaultProvider: updates.defaultProvider || currentPolicy.defaultProvider,
+            operations: {
+                ...currentPolicy.operations,
+                ...updates.operations,
+            },
+        };
+        // Validate the new policy
+        const validated = RoutingPolicySchema.parse(newPolicy);
+        // Ensure .vibeman directory exists
+        const vibemanDir = path.dirname(this.policyFilePath);
+        await fs.mkdir(vibemanDir, { recursive: true });
+        // Write to file
+        await fs.writeFile(this.policyFilePath, JSON.stringify(validated, null, 2), 'utf-8');
+        // Update in-memory policy
+        this.policy = validated;
+        this.lastModified = Date.now();
+        log.info('Updated AI routing policy', { policy: validated }, 'routing-policy');
+    }
+    /**
+     * Resolve provider for a specific operation
+     */
+    async resolveProviderForOperation(operation, overrides) {
+        const policy = await this.getPolicy();
+        const operationConfig = policy.operations?.[operation];
+        // Pull provider/model defaults from settings per operation
+        const settings = getSettingsService().getSettings();
+        const coding = settings.agents?.codingAgent;
+        const judge = settings.agents?.judgeAgent;
+        const settingsProviderModel = (() => {
+            switch (operation) {
+                case 'ai_codereview':
+                    return { provider: judge?.provider, model: judge?.model };
+                case 'execute_task':
+                case 'improve_task':
+                case 'ai_merge':
+                default:
+                    return { provider: coding?.provider, model: coding?.model };
+            }
+        })();
+        // Start with operation-specific config or fall back to settings, then default policy
+        const baseProvider = operationConfig?.provider || settingsProviderModel.provider || policy.defaultProvider;
+        const baseModel = operationConfig?.model || settingsProviderModel.model;
+        const baseOptions = operationConfig?.options;
+        const baseFallbacks = operationConfig?.fallback || [];
+        // Apply overrides
+        const resolved = {
+            provider: overrides?.provider || baseProvider,
+            model: overrides?.model || baseModel,
+            options: overrides?.options || baseOptions,
+            fallbacks: overrides?.fallbacks || baseFallbacks,
+        };
+        log.debug(`Resolved provider for ${operation}`, { operation, resolved }, 'routing-policy');
+        return resolved;
+    }
+    /**
+     * Set default provider
+     */
+    async setDefaultProvider(provider) {
+        await this.updatePolicy({ defaultProvider: provider });
+    }
+    /**
+     * Set operation-specific routing
+     */
+    async setOperationConfig(operation, config) {
+        const currentPolicy = await this.getPolicy();
+        await this.updatePolicy({
+            operations: {
+                ...currentPolicy.operations,
+                [operation]: config,
+            },
+        });
+    }
+    /**
+     * Validate policy against available providers
+     */
+    validatePolicy(policy, availableProviders) {
+        const errors = [];
+        // Check default provider
+        if (!availableProviders.has(policy.defaultProvider)) {
+            errors.push(`Default provider '${policy.defaultProvider}' is not available`);
+        }
+        // Check operation providers
+        if (policy.operations) {
+            for (const [operation, config] of Object.entries(policy.operations)) {
+                if (!availableProviders.has(config.provider)) {
+                    errors.push(`Provider '${config.provider}' for operation '${operation}' is not available`);
+                }
+                // Check fallback providers
+                if (config.fallback) {
+                    for (const fallbackProvider of config.fallback) {
+                        if (!availableProviders.has(fallbackProvider)) {
+                            errors.push(`Fallback provider '${fallbackProvider}' for operation '${operation}' is not available`);
+                        }
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    /**
+     * Load policy from file if it has changed
+     */
+    async loadPolicyIfChanged() {
+        try {
+            const stats = await fs.stat(this.policyFilePath);
+            const fileModified = stats.mtime.getTime();
+            // Only reload if file has changed
+            if (fileModified <= this.lastModified) {
+                return;
+            }
+            const content = await fs.readFile(this.policyFilePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            const validated = RoutingPolicySchema.parse(parsed);
+            this.policy = validated;
+            this.lastModified = fileModified;
+            log.info('Loaded AI routing policy', { policy: validated }, 'routing-policy');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist yet, use default
+                this.policy = null;
+                return;
+            }
+            log.warn('Failed to load routing policy, using defaults', error, 'routing-policy');
+            this.policy = null;
+        }
+    }
+    /**
+     * Create example policy file if it doesn't exist
+     */
+    async createExamplePolicy() {
+        const examplePath = path.join(getVibeDir(), 'ai-routing.example.json');
+        // Do not recreate if it already exists
+        try {
+            await fs.stat(examplePath);
+            return; // already exists; avoid noisy logs
+        }
+        catch (err) {
+            if (err?.code && err.code !== 'ENOENT') {
+                log.warn('Unable to stat example AI routing policy', err, 'routing-policy');
+                return;
+            }
+        }
+        const settings = getSettingsService().getSettings();
+        const example = {
+            defaultProvider: settings.agents.defaultProvider || 'claude-code',
+            operations: {
+                execute_task: {
+                    provider: settings.agents.defaultProvider || 'claude-code',
+                    model: 'claude-sonnet-4-20250514',
+                    fallback: ['codex'],
+                },
+                improve_task: {
+                    provider: settings.agents.defaultProvider || 'claude-code',
+                    model: 'claude-sonnet-4-20250514',
+                },
+                ai_codereview: {
+                    provider: 'codex',
+                    model: 'gpt-5',
+                },
+                ai_merge: {
+                    provider: settings.agents.defaultProvider || 'claude-code',
+                    model: 'claude-sonnet-4-20250514',
+                },
+            },
+        };
+        // Ensure .vibeman directory exists
+        const vibemanDir = path.dirname(examplePath);
+        await fs.mkdir(vibemanDir, { recursive: true });
+        await fs.writeFile(examplePath, JSON.stringify(example, null, 2), 'utf-8');
+        log.info('Created example AI routing policy', { path: examplePath }, 'routing-policy');
+    }
+    /**
+     * Get policy file path for external access
+     */
+    getPolicyFilePath() {
+        return this.policyFilePath;
+    }
+}

package/dist/runtime/api/api/router-helpers.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { TaskService } from '../tasks/task-service.js';
+export declare const TaskIdSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+}, {
+    taskId: string;
+}>;
+export declare const ExecutionIdSchema: z.ZodObject<{
+    executionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    executionId: string;
+}, {
+    executionId: string;
+}>;
+export declare const WorkflowIdSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    workflowId: string;
+}, {
+    workflowId: string;
+}>;
+export declare const WorktreePathSchema: z.ZodObject<{
+    worktreePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    worktreePath: string;
+}, {
+    worktreePath: string;
+}>;
+export declare const withErrors: <TArgs extends any[], TRes>(action: string, tag: string, fn: (...args: TArgs) => Promise<TRes>) => (...args: TArgs) => Promise<TRes>;
+export declare function makeAssertTaskActive(taskService: TaskService): (id: string) => import("../types/index.js").Task;

package/dist/runtime/api/api/router-helpers.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { log } from '../lib/logger.js';
+// Shared input schemas
+export const TaskIdSchema = z.object({ taskId: z.string() });
+export const ExecutionIdSchema = z.object({ executionId: z.string() });
+export const WorkflowIdSchema = z.object({ workflowId: z.string() });
+export const WorktreePathSchema = z.object({ worktreePath: z.string() });
+// Centralized error formatter for consistent messages
+export const withErrors = (action, tag, fn) => {
+    return async (...args) => {
+        try {
+            return await fn(...args);
+        }
+        catch (error) {
+            log.error(`Error in ${action}`, error, tag);
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to ${action}: ${msg}`);
+        }
+    };
+};
+// Factory for active-task assertion to avoid repeating checks
+export function makeAssertTaskActive(taskService) {
+    return (id) => {
+        const t = taskService.getTask(id);
+        if (!t)
+            throw new Error(`Task ${id} not found`);
+        if (t.deleted_at)
+            throw new Error(`Task ${id} is deleted`);
+        return t;
+    };
+}

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

@@ -0,0 +1,188 @@
+/**
+ * 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: {
+    requireAgentService: () => 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: any;
+        meta: object;
+    }>;
+    /**
+     * Update routing policy
+     */
+    updateRoutingPolicy: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            policy: {
+                defaultProvider?: string | undefined;
+                operations?: Partial<Record<"execute_task" | "improve_task" | "ai_codereview" | "ai_merge", {
+                    provider: string;
+                    options?: {
+                        maxTokens?: number | undefined;
+                        tools?: string[] | undefined;
+                        temperature?: number | 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: {
+            config: {
+                provider: string;
+                options?: {
+                    maxTokens?: number | undefined;
+                    tools?: string[] | undefined;
+                    temperature?: number | undefined;
+                } | undefined;
+                model?: string | undefined;
+                fallback?: string[] | undefined;
+            };
+            operation: "execute_task" | "improve_task" | "ai_codereview" | "ai_merge";
+        };
+        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: {
+    requireAgentService: () => 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;
+        }>;
+    }>;
+};