vibeman 0.0.1 → 0.0.3

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

@@ -3,11 +3,18 @@
  * 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';
+/**
+ * Operation types that support AI routing
+ */
+const ROUTABLE_OPERATIONS = [
+    'execute_task',
+    'quality_checks',
+    'ai_codereview',
+    'ai_merge',
+    'improve_task',
+];
 /**
  * Generation options for AI execution
  */
@@ -30,67 +37,83 @@ export const OperationConfigSchema = z.object({
  */
 export const RoutingPolicySchema = z.object({
     defaultProvider: z.string(),
-    operations: z
-        .record(z.enum(['execute_task', 'improve_task', 'ai_codereview', 'ai_merge']), OperationConfigSchema)
-        .optional(),
+    operations: z.record(z.enum(ROUTABLE_OPERATIONS), OperationConfigSchema).optional(),
 });
+export const ROUTABLE_OPERATION_LIST = ROUTABLE_OPERATIONS;
 /**
  * Routing Policy Manager
- * Manages AI provider routing policies with hot-reload capability
+ * Manages AI provider routing policies stored inside settings.json
  */
 export class RoutingPolicyManager {
     constructor() {
         this.policy = null;
-        this.lastModified = 0;
-        this.policyFilePath = path.join(getVibeDir(), 'ai-routing.json');
+        this.settingsService = getSettingsService();
+        // Invalidate cached policy when settings change
+        this.settingsService.on('settingsUpdated', () => {
+            this.policy = null;
+        });
     }
     /**
-     * Get current effective policy with hot-reload
+     * Get current effective policy (lazy loads from settings)
      */
     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: {},
-            };
+            this.policy = this.buildPolicyFromSettings();
         }
         return this.policy;
     }
     /**
-     * Update routing policy and persist to disk
+     * Update routing policy and persist via settings service
      */
     async updatePolicy(updates) {
         const currentPolicy = await this.getPolicy();
-        const newPolicy = {
-            defaultProvider: updates.defaultProvider || currentPolicy.defaultProvider,
-            operations: {
-                ...currentPolicy.operations,
-                ...updates.operations,
-            },
+        const mergedOperations = {
+            ...(currentPolicy.operations ?? {}),
+            ...(updates.operations ?? {}),
+        };
+        const operationsKeys = Object.keys(mergedOperations);
+        const nextPolicy = {
+            defaultProvider: updates.defaultProvider ?? currentPolicy.defaultProvider,
+            ...(operationsKeys.length > 0 ? { operations: mergedOperations } : {}),
         };
-        // 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
+        const validated = RoutingPolicySchema.parse(nextPolicy);
+        await this.settingsService.updateSettings([
+            { path: ['agents', 'routingPolicy'], value: validated },
+        ]);
         this.policy = validated;
-        this.lastModified = Date.now();
         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 = getSettingsService().getSettings();
+        const settings = this.settingsService.getSettings();
         const coding = settings.agents?.codingAgent;
         const judge = settings.agents?.judgeAgent;
         const settingsProviderModel = (() => {
@@ -98,61 +121,54 @@ export class RoutingPolicyManager {
                 case 'ai_codereview':
                     return { provider: judge?.provider, model: judge?.model };
                 case 'execute_task':
-                case 'improve_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 || settingsProviderModel.model;
+        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: overrides?.model || baseModel,
+            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;
     }
-    /**
-     * 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,
-            },
-        });
+        const operations = {
+            ...(currentPolicy.operations ?? {}),
+            [operation]: config,
+        };
+        await this.updatePolicy({ operations });
     }
-    /**
-     * 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)) {
@@ -164,83 +180,17 @@ export class RoutingPolicyManager {
         }
         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',
-                },
-            },
+    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 } : {}),
         };
-        // 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;
+        return RoutingPolicySchema.parse(policy);
     }
 }

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

@@ -0,0 +1,63 @@
+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/routers/ai.d.ts

@@ -8,7 +8,7 @@ import { type RoutingPolicy, type RoutableOperation } from '../../agent/routing-
  * Build AI router with required dependencies
  */
 export declare function buildAIRoutes(options: {
-    requireAgentService: () => AgentService;
+    agentService: AgentService;
 }): {
     /**
      * List all registered AI providers with health status
@@ -40,7 +40,19 @@ export declare function buildAIRoutes(options: {
      */
     getRoutingPolicy: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
-        output: any;
+        output: {
+            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;
+        };
         meta: object;
     }>;
     /**
@@ -50,12 +62,12 @@ export declare function buildAIRoutes(options: {
         input: {
             policy: {
                 defaultProvider?: string | undefined;
-                operations?: Partial<Record<"execute_task" | "improve_task" | "ai_codereview" | "ai_merge", {
+                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;
-                        temperature?: number | undefined;
                     } | undefined;
                     model?: string | undefined;
                     fallback?: string[] | undefined;
@@ -86,17 +98,17 @@ export declare function buildAIRoutes(options: {
      */
     setOperationConfig: import("@trpc/server").TRPCMutationProcedure<{
         input: {
+            operation: "execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview";
             config: {
                 provider: string;
                 options?: {
+                    temperature?: number | undefined;
                     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;
@@ -130,7 +142,7 @@ export declare function buildAIRoutes(options: {
  * Useful for unit tests that call functions directly.
  */
 export declare function buildAIRouteHandlers(options: {
-    requireAgentService: () => AgentService;
+    agentService: AgentService;
 }): {
     readonly listProviders: () => Promise<{
         name: string;

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

@@ -20,7 +20,7 @@ const SetDefaultProviderInputSchema = z.object({
     provider: z.string(),
 });
 const SetOperationConfigInputSchema = z.object({
-    operation: z.enum(['execute_task', 'improve_task', 'ai_codereview', 'ai_merge']),
+    operation: z.enum(['execute_task', 'quality_checks', 'ai_codereview', 'ai_merge', 'improve_task']),
     config: OperationConfigSchema,
 });
 const ValidateProvidersInputSchema = z.object({
@@ -30,14 +30,13 @@ const ValidateProvidersInputSchema = z.object({
  * Build AI router with required dependencies
  */
 export function buildAIRoutes(options) {
-    const { requireAgentService } = options;
+    const { agentService } = options;
     return {
         /**
          * List all registered AI providers with health status
          */
         listProviders: publicProcedure.query(async () => {
             try {
-                const agentService = requireAgentService();
                 const providers = agentService.getAvailableProviders();
                 const providerStatuses = await agentService.validateProviders();
                 const result = Array.from(providers.entries()).map(([name, provider]) => {
@@ -65,7 +64,6 @@ export function buildAIRoutes(options) {
          */
         listModels: publicProcedure.input(ListModelsInputSchema.optional()).query(async ({ input }) => {
             try {
-                const agentService = requireAgentService();
                 if (input?.provider) {
                     // Get models from specific provider
                     const provider = agentService.getAvailableProviders().get(input.provider);
@@ -94,17 +92,17 @@ export function buildAIRoutes(options) {
          */
         getRoutingPolicy: publicProcedure.query(async () => {
             try {
-                const agentService = requireAgentService();
-                const policy = await agentService.getRoutingPolicyManager()?.getPolicy();
-                if (!policy) {
-                    // Return default policy if none exists
+                const rpm = agentService.getRoutingPolicyManager?.();
+                if (!rpm) {
                     const settings = getSettingsService().getSettings();
-                    const defaultPolicy = {
+                    return {
                         defaultProvider: settings.agents.defaultProvider || 'claude-code',
                         operations: {},
                     };
-                    return defaultPolicy;
                 }
+                const policy = (rpm.getEffectivePolicy
+                    ? await rpm.getEffectivePolicy()
+                    : await rpm.getPolicy());
                 log.debug('Retrieved routing policy', { policy }, 'ai-router');
                 return policy;
             }
@@ -121,7 +119,6 @@ export function buildAIRoutes(options) {
             .input(UpdateRoutingPolicyInputSchema)
             .mutation(async ({ input }) => {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager();
                 if (!routingManager) {
                     throw new Error('Routing policy manager not available');
@@ -144,7 +141,6 @@ export function buildAIRoutes(options) {
             .input(SetDefaultProviderInputSchema)
             .mutation(async ({ input }) => {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager();
                 if (!routingManager) {
                     throw new Error('Routing policy manager not available');
@@ -171,7 +167,6 @@ export function buildAIRoutes(options) {
             .input(SetOperationConfigInputSchema)
             .mutation(async ({ input }) => {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager();
                 if (!routingManager) {
                     throw new Error('Routing policy manager not available');
@@ -206,7 +201,6 @@ export function buildAIRoutes(options) {
             .input(ValidateProvidersInputSchema.optional())
             .mutation(async ({ input }) => {
             try {
-                const agentService = requireAgentService();
                 const results = await agentService.validateProviders();
                 const validation = Array.from(results.entries()).map(([name, status]) => ({
                     provider: name,
@@ -239,11 +233,10 @@ export function buildAIRoutes(options) {
  * Useful for unit tests that call functions directly.
  */
 export function buildAIRouteHandlers(options) {
-    const { requireAgentService } = options;
+    const { agentService } = options;
     return {
         async listProviders() {
             try {
-                const agentService = requireAgentService();
                 const providers = agentService.getAvailableProviders();
                 const providerStatuses = await agentService.validateProviders();
                 return Array.from(providers.entries()).map(([name, provider]) => {
@@ -264,7 +257,6 @@ export function buildAIRouteHandlers(options) {
         },
         async listModels(input) {
             try {
-                const agentService = requireAgentService();
                 if (input?.provider) {
                     const provider = agentService.getAvailableProviders().get(input.provider);
                     if (!provider)
@@ -279,7 +271,6 @@ export function buildAIRouteHandlers(options) {
         },
         async getRoutingPolicy() {
             try {
-                const agentService = requireAgentService();
                 const rpm = agentService.getRoutingPolicyManager?.() ||
                     agentService.routingPolicyManager;
                 const policy = await rpm?.getPolicy();
@@ -298,7 +289,6 @@ export function buildAIRouteHandlers(options) {
         },
         async updateRoutingPolicy(input) {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager?.() ||
                     agentService.routingPolicyManager;
                 if (!routingManager)
@@ -313,7 +303,6 @@ export function buildAIRouteHandlers(options) {
         },
         async setDefaultProvider(input) {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager?.() ||
                     agentService.routingPolicyManager;
                 if (!routingManager)
@@ -330,7 +319,6 @@ export function buildAIRouteHandlers(options) {
         },
         async setOperationConfig(input) {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager?.() ||
                     agentService.routingPolicyManager;
                 if (!routingManager)
@@ -355,7 +343,6 @@ export function buildAIRouteHandlers(options) {
         },
         async validateProviders() {
             try {
-                const agentService = requireAgentService();
                 const results = await agentService.validateProviders();
                 const validation = Array.from(results.entries()).map(([name, status]) => ({
                     provider: name,
@@ -377,7 +364,6 @@ export function buildAIRouteHandlers(options) {
         },
         async getProviderHealth() {
             try {
-                const agentService = requireAgentService();
                 const providers = agentService.getAvailableProviders();
                 const statuses = await agentService.validateProviders();
                 const health = {

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

@@ -2,10 +2,9 @@ import type { TaskService } from '../../tasks/task-service.js';
 import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
 type Deps = {
     taskService: TaskService;
-    requireOrchestrator: () => Promise<VibingOrchestrator>;
-    requireOrchestratorSync: () => VibingOrchestrator;
+    vibingOrchestrator: VibingOrchestrator;
 };
-export declare function buildExecutionRoutes({ taskService, requireOrchestrator, requireOrchestratorSync, }: Deps): {
+export declare function buildExecutionRoutes({ taskService, vibingOrchestrator }: Deps): {
     readonly executeTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             taskId: string;
@@ -66,9 +65,9 @@ export declare function buildExecutionRoutes({ taskService, requireOrchestrator,
     }>;
     readonly improveTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
+            title: string;
             type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
             priority: "low" | "medium" | "high";
-            title: string;
             content: string;
             taskId: string;
             executionId?: string | undefined;
@@ -77,6 +76,7 @@ export declare function buildExecutionRoutes({ taskService, requireOrchestrator,
             type: string;
             priority: string;
             content: string;
+            title?: string;
             executionId: string;
             selectedModel?: string;
         };