vibeman 0.0.5 → 0.0.6

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

@@ -1,63 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
-import { RoutingPolicyManager, } from './routing-policy.js';
-import { getSettingsService } from '../settings-service.js';
-const settingsService = getSettingsService();
-const BASE_POLICY = {
-    defaultProvider: 'claude-code',
-    operations: {},
-};
-let originalRoutingPolicy;
-async function setRoutingPolicy(value) {
-    const result = await settingsService.updateSettings([
-        { path: ['agents', 'routingPolicy'], value },
-    ]);
-    if (!result.success) {
-        throw new Error(`Failed to set routing policy: ${JSON.stringify(result.errors)}`);
-    }
-}
-describe('RoutingPolicyManager resolve precedence', () => {
-    beforeAll(async () => {
-        await settingsService.initialize();
-        const manager = new RoutingPolicyManager();
-        originalRoutingPolicy = await manager.getPolicy();
-        await setRoutingPolicy(BASE_POLICY);
-    });
-    afterEach(async () => {
-        await setRoutingPolicy(BASE_POLICY);
-    });
-    afterAll(async () => {
-        await setRoutingPolicy(originalRoutingPolicy);
-    });
-    it('falls back to settings when no operation config or overrides', async () => {
-        const rpm = new RoutingPolicyManager();
-        const resolved = await rpm.resolveProviderForOperation('execute_task');
-        expect(resolved.provider).toBe('claude-code');
-        expect(resolved.model).toBe('claude-sonnet-4-20250514');
-    });
-    it('uses operation-specific policy when provided', async () => {
-        const rpm = new RoutingPolicyManager();
-        await rpm.updatePolicy({
-            operations: {
-                ai_merge: { provider: 'codex', model: 'gpt-5.1-codex' },
-            },
-        });
-        const resolved = await rpm.resolveProviderForOperation('ai_merge');
-        expect(resolved.provider).toBe('codex');
-        expect(resolved.model).toBe('gpt-5.1-codex');
-    });
-    it('when override sets provider without model, does not inherit mismatched model', async () => {
-        const rpm = new RoutingPolicyManager();
-        await rpm.updatePolicy({ operations: {} });
-        const override = { provider: 'codex' };
-        const resolved = await rpm.resolveProviderForOperation('execute_task', override);
-        expect(resolved.provider).toBe('codex');
-        expect(resolved.model).toBeUndefined();
-    });
-    it('override with provider+model takes full precedence', async () => {
-        const rpm = new RoutingPolicyManager();
-        const override = { provider: 'codex', model: 'gpt-5.1-codex' };
-        const resolved = await rpm.resolveProviderForOperation('execute_task', override);
-        expect(resolved.provider).toBe('codex');
-        expect(resolved.model).toBe('gpt-5.1-codex');
-    });
-});

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

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

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

@@ -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" | "ai_codereview" | "ai_merge" | "improve_task", {
-                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" | "ai_codereview" | "ai_merge" | "improve_task", {
-                    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: {
-            config: {
-                provider: string;
-                options?: {
-                    temperature?: number | undefined;
-                    maxTokens?: number | undefined;
-                    tools?: string[] | undefined;
-                } | undefined;
-                model?: string | undefined;
-                fallback?: string[] | undefined;
-            };
-            operation: "execute_task" | "quality_checks" | "ai_codereview" | "ai_merge" | "improve_task";
-        };
-        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;
-        }>;
-    }>;
-};