vibeman 0.0.3 → 0.0.6

package/dist/runtime/api/agent/routing-policy.d.ts

@@ -1,171 +0,0 @@
-/**
- * AI Routing Policy Management
- * Handles provider selection per operation with fallbacks and configuration
- */
-import { z } from 'zod';
-/**
- * Operation types that support AI routing
- */
-declare const ROUTABLE_OPERATIONS: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
-export type RoutableOperation = (typeof ROUTABLE_OPERATIONS)[number];
-/**
- * Generation options for AI execution
- */
-export declare const GenerationOptionsSchema: z.ZodObject<{
-    temperature: z.ZodOptional<z.ZodNumber>;
-    maxTokens: z.ZodOptional<z.ZodNumber>;
-    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    temperature?: number | undefined;
-    maxTokens?: number | undefined;
-    tools?: string[] | undefined;
-}, {
-    temperature?: number | undefined;
-    maxTokens?: number | undefined;
-    tools?: string[] | undefined;
-}>;
-export type GenerationOptions = z.infer<typeof GenerationOptionsSchema>;
-/**
- * Per-operation routing configuration
- */
-export declare const OperationConfigSchema: z.ZodObject<{
-    provider: z.ZodString;
-    model: z.ZodOptional<z.ZodString>;
-    options: z.ZodOptional<z.ZodObject<{
-        temperature: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        temperature?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: string[] | undefined;
-    }, {
-        temperature?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: string[] | undefined;
-    }>>;
-    fallback: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    provider: string;
-    options?: {
-        temperature?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: string[] | undefined;
-    } | undefined;
-    model?: string | undefined;
-    fallback?: string[] | undefined;
-}, {
-    provider: string;
-    options?: {
-        temperature?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: string[] | undefined;
-    } | undefined;
-    model?: string | undefined;
-    fallback?: string[] | undefined;
-}>;
-export type OperationConfig = z.infer<typeof OperationConfigSchema>;
-/**
- * Complete routing policy schema
- */
-export declare const RoutingPolicySchema: z.ZodObject<{
-    defaultProvider: z.ZodString;
-    operations: z.ZodOptional<z.ZodRecord<z.ZodEnum<["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"]>, z.ZodObject<{
-        provider: z.ZodString;
-        model: z.ZodOptional<z.ZodString>;
-        options: z.ZodOptional<z.ZodObject<{
-            temperature: z.ZodOptional<z.ZodNumber>;
-            maxTokens: z.ZodOptional<z.ZodNumber>;
-            tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        }, {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        }>>;
-        fallback: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        provider: string;
-        options?: {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        } | undefined;
-        model?: string | undefined;
-        fallback?: string[] | undefined;
-    }, {
-        provider: string;
-        options?: {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        } | undefined;
-        model?: string | undefined;
-        fallback?: string[] | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    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;
-}, {
-    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;
-}>;
-export type RoutingPolicy = z.infer<typeof RoutingPolicySchema>;
-export declare const ROUTABLE_OPERATION_LIST: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
-/**
- * Resolved provider configuration for execution
- */
-export interface ResolvedProvider {
-    provider: string;
-    model?: string;
-    options?: GenerationOptions;
-    fallbacks?: string[];
-}
-/**
- * Routing Policy Manager
- * Manages AI provider routing policies stored inside settings.json
- */
-export declare class RoutingPolicyManager {
-    private policy;
-    private readonly settingsService;
-    constructor();
-    /**
-     * Get current effective policy (lazy loads from settings)
-     */
-    getPolicy(): Promise<RoutingPolicy>;
-    /**
-     * Update routing policy and persist via settings service
-     */
-    updatePolicy(updates: Partial<RoutingPolicy>): Promise<void>;
-    /**
-     * Resolve provider for a specific operation
-     */
-    getEffectivePolicy(): Promise<RoutingPolicy>;
-    resolveProviderForOperation(operation: RoutableOperation, overrides?: Partial<ResolvedProvider>): Promise<ResolvedProvider>;
-    setDefaultProvider(provider: string): Promise<void>;
-    setOperationConfig(operation: RoutableOperation, config: OperationConfig): Promise<void>;
-    validatePolicy(policy: RoutingPolicy, availableProviders: Set<string>): string[];
-    private buildPolicyFromSettings;
-}
-export {};

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

@@ -1,196 +0,0 @@
-/**
- * AI Routing Policy Management
- * Handles provider selection per operation with fallbacks and configuration
- */
-import { z } from 'zod';
-import { log } from '../lib/logger.js';
-import { getSettingsService } from '../settings-service.js';
-/**
- * Operation types that support AI routing
- */
-const ROUTABLE_OPERATIONS = [
-    'execute_task',
-    'quality_checks',
-    'ai_codereview',
-    'ai_merge',
-    'improve_task',
-];
-/**
- * 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(ROUTABLE_OPERATIONS), OperationConfigSchema).optional(),
-});
-export const ROUTABLE_OPERATION_LIST = ROUTABLE_OPERATIONS;
-/**
- * Routing Policy Manager
- * Manages AI provider routing policies stored inside settings.json
- */
-export class RoutingPolicyManager {
-    constructor() {
-        this.policy = null;
-        this.settingsService = getSettingsService();
-        // Invalidate cached policy when settings change
-        this.settingsService.on('settingsUpdated', () => {
-            this.policy = null;
-        });
-    }
-    /**
-     * Get current effective policy (lazy loads from settings)
-     */
-    async getPolicy() {
-        if (!this.policy) {
-            this.policy = this.buildPolicyFromSettings();
-        }
-        return this.policy;
-    }
-    /**
-     * Update routing policy and persist via settings service
-     */
-    async updatePolicy(updates) {
-        const currentPolicy = await this.getPolicy();
-        const mergedOperations = {
-            ...(currentPolicy.operations ?? {}),
-            ...(updates.operations ?? {}),
-        };
-        const operationsKeys = Object.keys(mergedOperations);
-        const nextPolicy = {
-            defaultProvider: updates.defaultProvider ?? currentPolicy.defaultProvider,
-            ...(operationsKeys.length > 0 ? { operations: mergedOperations } : {}),
-        };
-        const validated = RoutingPolicySchema.parse(nextPolicy);
-        await this.settingsService.updateSettings([
-            { path: ['agents', 'routingPolicy'], value: validated },
-        ]);
-        this.policy = validated;
-        log.info('Updated AI routing policy', { policy: validated }, 'routing-policy');
-    }
-    /**
-     * Resolve provider for a specific operation
-     */
-    async getEffectivePolicy() {
-        const base = await this.getPolicy();
-        const operations = {
-            ...base.operations,
-        };
-        for (const op of ROUTABLE_OPERATIONS) {
-            if (!operations[op]) {
-                const resolved = await this.resolveProviderForOperation(op);
-                operations[op] = {
-                    provider: resolved.provider,
-                    ...(resolved.model ? { model: resolved.model } : {}),
-                    ...(resolved.options ? { options: resolved.options } : {}),
-                    ...(resolved.fallbacks && resolved.fallbacks.length
-                        ? { fallback: resolved.fallbacks }
-                        : {}),
-                };
-            }
-        }
-        return {
-            defaultProvider: base.defaultProvider,
-            operations,
-        };
-    }
-    async resolveProviderForOperation(operation, overrides) {
-        const policy = await this.getPolicy();
-        const operationConfig = policy.operations?.[operation];
-        // Pull provider/model defaults from settings per operation
-        const settings = this.settingsService.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 'quality_checks':
-                case 'ai_merge':
-                case 'improve_task':
-                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
-            ? operationConfig.model
-            : operationConfig?.provider
-                ? undefined
-                : settingsProviderModel.model;
-        const baseOptions = operationConfig?.options;
-        const baseFallbacks = operationConfig?.fallback || [];
-        // Apply overrides
-        const overrideProviderOnly = overrides?.provider && overrides.model === undefined;
-        const resolved = {
-            provider: overrides?.provider || baseProvider,
-            model: overrideProviderOnly ? undefined : overrides?.model || baseModel,
-            options: overrides?.options || baseOptions,
-            fallbacks: overrides?.fallbacks || baseFallbacks,
-        };
-        log.debug(`Resolved provider for ${operation}`, { operation, resolved }, 'routing-policy');
-        return resolved;
-    }
-    async setDefaultProvider(provider) {
-        await this.updatePolicy({ defaultProvider: provider });
-    }
-    async setOperationConfig(operation, config) {
-        const currentPolicy = await this.getPolicy();
-        const operations = {
-            ...(currentPolicy.operations ?? {}),
-            [operation]: config,
-        };
-        await this.updatePolicy({ operations });
-    }
-    validatePolicy(policy, availableProviders) {
-        const errors = [];
-        if (!availableProviders.has(policy.defaultProvider)) {
-            errors.push(`Default provider '${policy.defaultProvider}' is not available`);
-        }
-        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`);
-                }
-                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;
-    }
-    buildPolicyFromSettings() {
-        const settings = this.settingsService.getSettings();
-        const settingsPolicy = settings.agents?.routingPolicy;
-        const defaultProvider = settingsPolicy?.defaultProvider || settings.agents.defaultProvider || 'claude-code';
-        const operations = settingsPolicy?.operations
-            ? { ...settingsPolicy.operations }
-            : undefined;
-        const policy = {
-            defaultProvider,
-            ...(operations ? { operations } : {}),
-        };
-        return RoutingPolicySchema.parse(policy);
-    }
-}

package/dist/runtime/api/agent/routing-policy.test.d.ts

@@ -1 +0,0 @@
-export {};

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' },
-            },
-        });
-        const resolved = await rpm.resolveProviderForOperation('ai_merge');
-        expect(resolved.provider).toBe('codex');
-        expect(resolved.model).toBe('gpt-5');
-    });
-    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' };
-        const resolved = await rpm.resolveProviderForOperation('execute_task', override);
-        expect(resolved.provider).toBe('codex');
-        expect(resolved.model).toBe('gpt-5');
-    });
-});

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;
-    };
-}