vibeman 0.0.1 → 0.0.2

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

@@ -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,7 +92,6 @@ 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
@@ -121,7 +118,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 +140,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 +166,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 +200,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 +232,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 +256,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 +270,6 @@ export function buildAIRouteHandlers(options) {
         },
         async getRoutingPolicy() {
             try {
-                const agentService = requireAgentService();
                 const rpm = agentService.getRoutingPolicyManager?.() ||
                     agentService.routingPolicyManager;
                 const policy = await rpm?.getPolicy();
@@ -298,7 +288,6 @@ export function buildAIRouteHandlers(options) {
         },
         async updateRoutingPolicy(input) {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager?.() ||
                     agentService.routingPolicyManager;
                 if (!routingManager)
@@ -313,7 +302,6 @@ export function buildAIRouteHandlers(options) {
         },
         async setDefaultProvider(input) {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager?.() ||
                     agentService.routingPolicyManager;
                 if (!routingManager)
@@ -330,7 +318,6 @@ export function buildAIRouteHandlers(options) {
         },
         async setOperationConfig(input) {
             try {
-                const agentService = requireAgentService();
                 const routingManager = agentService.getRoutingPolicyManager?.() ||
                     agentService.routingPolicyManager;
                 if (!routingManager)
@@ -355,7 +342,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 +363,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: {
-            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-            priority: "low" | "medium" | "high";
             title: string;
+            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+            priority: "high" | "medium" | "low";
             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;
         };

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

@@ -4,34 +4,29 @@ 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, requireOrchestrator, requireOrchestratorSync, }) {
+export function buildExecutionRoutes({ taskService, vibingOrchestrator }) {
     const assertTaskActive = makeAssertTaskActive(taskService);
     return {
         executeTask: publicProcedure.input(TaskIdSchema).mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
             assertTaskActive(input.taskId);
-            const { executionId } = await orchestrator.executeTask(input.taskId);
+            const { executionId } = await vibingOrchestrator.executeTask(input.taskId);
             return { executionId };
         }),
         stopTaskExecution: publicProcedure.input(ExecutionIdSchema).mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
-            await orchestrator.stopExecution(input.executionId);
+            await vibingOrchestrator.stopExecution(input.executionId);
             return { success: true };
         }),
         getTaskExecutionStatus: publicProcedure.input(ExecutionIdSchema).query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
-            return orchestrator.getExecutionStatus(input.executionId);
+            return vibingOrchestrator.getExecutionStatus(input.executionId);
         }),
         getTaskExecutionLogs: publicProcedure.input(ExecutionIdSchema).query(async ({ input }) => {
             try {
-                const orchestrator = await requireOrchestrator();
-                const persistedLogs = await orchestrator.getPersistedExecutionLogs(input.executionId);
+                const persistedLogs = await vibingOrchestrator.getPersistedExecutionLogs(input.executionId);
                 return { logs: persistedLogs.logs };
             }
             catch (error) {
                 log.error('Failed to get task execution logs', error);
-                const orchestrator = await requireOrchestrator();
-                const logs = orchestrator.getExecutionLogs(input.executionId);
+                const logs = vibingOrchestrator.getExecutionLogs(input.executionId);
                 const logEntries = logs.map((message, index) => ({
                     timestamp: new Date().toISOString(),
                     level: 'info',
@@ -42,12 +37,10 @@ export function buildExecutionRoutes({ taskService, requireOrchestrator, require
             }
         }),
         getTaskExecutions: publicProcedure.input(TaskIdSchema).query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
-            return orchestrator.getTaskExecutions(input.taskId);
+            return vibingOrchestrator.getTaskExecutions(input.taskId);
         }),
         getTaskExecutionStats: publicProcedure.query(async () => {
-            const orchestrator = await requireOrchestrator();
-            return orchestrator.getExecutionStats();
+            return vibingOrchestrator.getExecutionStats();
         }),
         improveTask: publicProcedure
             .input(z.object({
@@ -60,8 +53,7 @@ export function buildExecutionRoutes({ taskService, requireOrchestrator, require
         }))
             .mutation(async ({ input }) => {
             assertTaskActive(input.taskId);
-            const orchestrator = await requireOrchestrator();
-            const improvement = await orchestrator.improveTaskContent(input.taskId, {
+            const improvement = await vibingOrchestrator.improveTaskContent(input.taskId, {
                 title: input.title,
                 type: input.type,
                 priority: input.priority,
@@ -73,9 +65,8 @@ export function buildExecutionRoutes({ taskService, requireOrchestrator, require
             .input(z.object({ executionId: z.string() }))
             .subscription(async function* (opts) {
             const input = opts.input;
-            const orchestrator = requireOrchestratorSync();
             // Emit initial status if exists
-            const initial = orchestrator.getExecutionStatus(input.executionId);
+            const initial = vibingOrchestrator.getExecutionStatus(input.executionId);
             if (initial) {
                 yield {
                     executionId: initial.id,
@@ -89,14 +80,14 @@ export function buildExecutionRoutes({ taskService, requireOrchestrator, require
                 if (update.executionId === input.executionId)
                     proxy.emit('data', update);
             };
-            orchestrator.on('executionUpdated', handleUpdate);
+            vibingOrchestrator.on('executionUpdated', handleUpdate);
             try {
                 for await (const [payload] of on(proxy, 'data', { signal: opts.signal })) {
                     yield payload;
                 }
             }
             finally {
-                orchestrator.off('executionUpdated', handleUpdate);
+                vibingOrchestrator.off('executionUpdated', handleUpdate);
             }
         }),
     };

package/dist/runtime/api/api/routers/provider-config.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Provider Configuration Router
+ * Handles provider detection and local configuration management
+ */
+/**
+ * Provider Configuration Router
+ */
+export declare function buildProviderConfigRoutes(): {
+    /**
+     * Detect all providers with current status
+     */
+    detectAllProviders: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, import("../../lib/provider-detection.js").DetectionResult>;
+        meta: object;
+    }>;
+    /**
+     * Detect specific provider
+     */
+    detectProvider: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            provider: string;
+        };
+        output: import("../../lib/provider-detection.js").DetectionResult;
+        meta: object;
+    }>;
+    /**
+     * Set explicit provider path
+     */
+    setProviderPath: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            path: string;
+            provider: string;
+        };
+        output: {
+            success: boolean;
+            result: import("../../lib/provider-detection.js").DetectionResult;
+        };
+        meta: object;
+    }>;
+    /**
+     * Clear provider path (reset to auto-detection)
+     */
+    clearProviderPath: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            provider: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get local configuration info
+     */
+    getLocalConfigInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            providers: {
+                'claude-code'?: {
+                    binPath?: string | undefined;
+                    detectedPath?: string | undefined;
+                    lastDetected?: string | undefined;
+                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+                } | undefined;
+                codex?: {
+                    binPath?: string | undefined;
+                    detectedPath?: string | undefined;
+                    lastDetected?: string | undefined;
+                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+                } | undefined;
+            };
+            path: string;
+            exists: boolean;
+            size?: number;
+        };
+        meta: object;
+    }>;
+    /**
+     * Clear validation cache (force re-detection)
+     */
+    clearValidationCache: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get provider detection diagnostics
+     */
+    getProviderDiagnostics: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            localConfigPath: string;
+            localConfigExists: boolean;
+            providers: {
+                provider: string;
+                detection: import("../../lib/provider-detection.js").DetectionResult;
+                localConfig: {
+                    binPath?: string | undefined;
+                    detectedPath?: string | undefined;
+                    lastDetected?: string | undefined;
+                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+                } | {
+                    binPath?: string | undefined;
+                    detectedPath?: string | undefined;
+                    lastDetected?: string | undefined;
+                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+                } | undefined;
+                cached: {
+                    available: boolean;
+                    error: string | undefined;
+                    version: string | undefined;
+                    checkedAt: string;
+                    isFresh: boolean;
+                } | null;
+            }[];
+        };
+        meta: object;
+    }>;
+};
+/**
+ * Test-friendly plain handlers
+ */
+export declare function buildProviderConfigRouteHandlers(): {
+    readonly detectAllProviders: () => Promise<Record<string, import("../../lib/provider-detection.js").DetectionResult>>;
+    readonly detectProvider: (input: {
+        provider: string;
+    }) => Promise<import("../../lib/provider-detection.js").DetectionResult>;
+    readonly setProviderPath: (input: {
+        provider: string;
+        path: string;
+    }) => Promise<{
+        success: true;
+        result: import("../../lib/provider-detection.js").DetectionResult;
+    }>;
+    readonly clearProviderPath: (input: {
+        provider: string;
+    }) => Promise<{
+        success: true;
+    }>;
+    readonly getLocalConfigInfo: () => Promise<{
+        providers: {
+            'claude-code'?: {
+                binPath?: string | undefined;
+                detectedPath?: string | undefined;
+                lastDetected?: string | undefined;
+                detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+            } | undefined;
+            codex?: {
+                binPath?: string | undefined;
+                detectedPath?: string | undefined;
+                lastDetected?: string | undefined;
+                detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+            } | undefined;
+        };
+        path: string;
+        exists: boolean;
+        size?: number;
+    }>;
+    readonly clearValidationCache: () => Promise<{
+        success: true;
+    }>;
+};

package/dist/runtime/api/api/routers/provider-config.js

@@ -0,0 +1,252 @@
+/**
+ * Provider Configuration Router
+ * Handles provider detection and local configuration management
+ */
+import { z } from 'zod';
+import { publicProcedure } from '../trpc.js';
+import { getProviderDetectionService } from '../../lib/provider-detection.js';
+import { getLocalConfigService } from '../../lib/local-config.js';
+import { log } from '../../lib/logger.js';
+/**
+ * Input schemas for API endpoints
+ */
+const DetectProviderInputSchema = z.object({
+    provider: z.string(),
+});
+const SetProviderPathInputSchema = z.object({
+    provider: z.string(),
+    path: z.string().trim().min(1, 'Path is required'),
+});
+const ClearProviderPathInputSchema = z.object({
+    provider: z.string(),
+});
+/**
+ * Provider Configuration Router
+ */
+export function buildProviderConfigRoutes() {
+    return {
+        /**
+         * Detect all providers with current status
+         */
+        detectAllProviders: publicProcedure.query(async () => {
+            try {
+                const detectionService = getProviderDetectionService();
+                const results = await detectionService.detectAllProviders();
+                log.debug('Detected all providers', { results }, 'provider-config');
+                return results;
+            }
+            catch (error) {
+                const msg = `Failed to detect providers: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Detect specific provider
+         */
+        detectProvider: publicProcedure.input(DetectProviderInputSchema).query(async ({ input }) => {
+            try {
+                const detectionService = getProviderDetectionService();
+                const result = await detectionService.detectProvider(input.provider);
+                log.debug('Detected provider', { provider: input.provider, result }, 'provider-config');
+                return result;
+            }
+            catch (error) {
+                const msg = `Failed to detect provider ${input.provider}: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Set explicit provider path
+         */
+        setProviderPath: publicProcedure
+            .input(SetProviderPathInputSchema)
+            .mutation(async ({ input }) => {
+            try {
+                const detectionService = getProviderDetectionService();
+                const result = await detectionService.setProviderPath(input.provider, input.path);
+                if (!result.found) {
+                    throw new Error(result.error || 'Invalid provider path');
+                }
+                log.info('Set provider path', { provider: input.provider, path: input.path }, 'provider-config');
+                return { success: true, result };
+            }
+            catch (error) {
+                const msg = `Failed to set provider path: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Clear provider path (reset to auto-detection)
+         */
+        clearProviderPath: publicProcedure
+            .input(ClearProviderPathInputSchema)
+            .mutation(async ({ input }) => {
+            try {
+                const detectionService = getProviderDetectionService();
+                await detectionService.clearProviderPath(input.provider);
+                log.info('Cleared provider path', { provider: input.provider }, 'provider-config');
+                return { success: true };
+            }
+            catch (error) {
+                const msg = `Failed to clear provider path: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Get local configuration info
+         */
+        getLocalConfigInfo: publicProcedure.query(async () => {
+            try {
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                const info = await localConfig.getConfigInfo();
+                const config = localConfig.getConfig();
+                return {
+                    ...info,
+                    providers: config.providers || {},
+                };
+            }
+            catch (error) {
+                const msg = `Failed to get local config info: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Clear validation cache (force re-detection)
+         */
+        clearValidationCache: publicProcedure.mutation(async () => {
+            try {
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                await localConfig.clearValidationCache();
+                log.info('Cleared validation cache', undefined, 'provider-config');
+                return { success: true };
+            }
+            catch (error) {
+                const msg = `Failed to clear validation cache: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+        /**
+         * Get provider detection diagnostics
+         */
+        getProviderDiagnostics: publicProcedure.query(async () => {
+            try {
+                const detectionService = getProviderDetectionService();
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                const detectionResults = await detectionService.detectAllProviders();
+                const localConfigInfo = await localConfig.getConfigInfo();
+                const providerConfigs = localConfig.getConfig().providers || {};
+                const diagnostics = Object.entries(detectionResults).map(([provider, result]) => {
+                    const config = providerConfigs[provider];
+                    const cached = localConfig.getCachedValidationResult(provider);
+                    return {
+                        provider,
+                        detection: result,
+                        localConfig: config,
+                        cached: cached
+                            ? {
+                                available: cached.available,
+                                error: cached.error,
+                                version: cached.version,
+                                checkedAt: cached.checkedAt,
+                                isFresh: localConfig.isCachedValidationFresh(provider),
+                            }
+                            : null,
+                    };
+                });
+                return {
+                    localConfigPath: localConfigInfo.path,
+                    localConfigExists: localConfigInfo.exists,
+                    providers: diagnostics,
+                };
+            }
+            catch (error) {
+                const msg = `Failed to get provider diagnostics: ${error instanceof Error ? error.message : String(error)}`;
+                log.error(msg, error, 'provider-config');
+                throw new Error(msg);
+            }
+        }),
+    };
+}
+/**
+ * Test-friendly plain handlers
+ */
+export function buildProviderConfigRouteHandlers() {
+    return {
+        async detectAllProviders() {
+            try {
+                const detectionService = getProviderDetectionService();
+                return await detectionService.detectAllProviders();
+            }
+            catch (error) {
+                throw new Error(`Failed to detect providers: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async detectProvider(input) {
+            try {
+                const detectionService = getProviderDetectionService();
+                return await detectionService.detectProvider(input.provider);
+            }
+            catch (error) {
+                throw new Error(`Failed to detect provider ${input.provider}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async setProviderPath(input) {
+            try {
+                const detectionService = getProviderDetectionService();
+                const result = await detectionService.setProviderPath(input.provider, input.path);
+                if (!result.found) {
+                    throw new Error(result.error || 'Invalid provider path');
+                }
+                return { success: true, result };
+            }
+            catch (error) {
+                throw new Error(`Failed to set provider path: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async clearProviderPath(input) {
+            try {
+                const detectionService = getProviderDetectionService();
+                await detectionService.clearProviderPath(input.provider);
+                return { success: true };
+            }
+            catch (error) {
+                throw new Error(`Failed to clear provider path: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async getLocalConfigInfo() {
+            try {
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                const info = await localConfig.getConfigInfo();
+                const config = localConfig.getConfig();
+                return {
+                    ...info,
+                    providers: config.providers || {},
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get local config info: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+        async clearValidationCache() {
+            try {
+                const localConfig = getLocalConfigService();
+                await localConfig.initialize();
+                await localConfig.clearValidationCache();
+                return { success: true };
+            }
+            catch (error) {
+                throw new Error(`Failed to clear validation cache: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+    };
+}