vibeman 0.0.1 → 0.0.3

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)}`);
+            }
+        },
+    };
+}

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

@@ -3,11 +3,11 @@ import type { GitService } from '../../vcs/git-service.js';
 export declare function buildTaskRoutes(taskService: TaskService, gitService?: GitService): {
     readonly listTasks: import("@trpc/server").TRPCQueryProcedure<{
         input: {
+            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
             type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+            tags?: string[] | undefined;
             priority?: "low" | "medium" | "high" | undefined;
             search?: string | undefined;
-            tags?: string[] | undefined;
             includeDeleted?: boolean | undefined;
             onlyDeleted?: boolean | undefined;
         } | undefined;
@@ -23,15 +23,15 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
     }>;
     readonly createTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
             title: string;
+            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
             content: string;
-            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-            priority?: "low" | "medium" | "high" | undefined;
+            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
             id?: string | undefined;
             tags?: string[] | undefined;
             due_date?: string | undefined;
             assignee?: string[] | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             comments?: string[] | undefined;
         };
         output: import("../../types/index.js").Task;
@@ -40,13 +40,13 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
     readonly updateTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             id: string;
-            type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-            priority?: "low" | "medium" | "high" | undefined;
+            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
             title?: string | undefined;
+            type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
             tags?: string[] | undefined;
             due_date?: string | undefined;
             assignee?: string[] | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             comments?: string[] | undefined;
             content?: string | undefined;
             deleted_at?: string | undefined;
@@ -65,7 +65,7 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
     }>;
     readonly moveTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            status: "backlog" | "in-progress" | "review" | "done";
+            status: "review" | "in-progress" | "backlog" | "done";
             id: string;
         };
         output: import("../../types/index.js").Task;

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

@@ -1,29 +1,29 @@
 import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
 type Deps = {
-    requireOrchestrator: () => Promise<VibingOrchestrator>;
-    requireOrchestratorSync: () => VibingOrchestrator;
+    vibingOrchestrator: VibingOrchestrator;
 };
-export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSync }: Deps): {
+export declare function buildWorkflowRoutes({ vibingOrchestrator }: Deps): {
     readonly updateWorkflowOptions: import("@trpc/server").TRPCMutationProcedure<{
         input: {
+            workflowId: string;
             config: {
+                autoCommit?: boolean | undefined;
+                createPR?: boolean | undefined;
                 autoQualityChecks?: boolean | undefined;
                 requireHumanApproval?: boolean | undefined;
-                aiCodeReview?: boolean | undefined;
-                autoCommit?: boolean | undefined;
                 stepByStepMode?: boolean | undefined;
-                createPR?: boolean | undefined;
                 autoMerge?: boolean | undefined;
+                aiCodeReview?: boolean | undefined;
                 aiRoutingOverrides?: {
                     execute_task?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
-                    improve_task?: {
+                    quality_checks?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
-                    ai_codereview?: {
+                    improve_task?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
@@ -31,9 +31,12 @@ export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrches
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
+                    ai_codereview?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
                 } | undefined;
             };
-            workflowId: string;
         };
         output: {
             readonly success: true;
@@ -44,23 +47,23 @@ export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrches
         input: {
             taskId: string;
             config?: {
+                autoCommit?: boolean | undefined;
+                createPR?: boolean | undefined;
                 autoQualityChecks?: boolean | undefined;
                 requireHumanApproval?: boolean | undefined;
-                aiCodeReview?: boolean | undefined;
-                autoCommit?: boolean | undefined;
                 stepByStepMode?: boolean | undefined;
-                createPR?: boolean | undefined;
                 autoMerge?: boolean | undefined;
+                aiCodeReview?: boolean | undefined;
                 aiRoutingOverrides?: {
                     execute_task?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
-                    improve_task?: {
+                    quality_checks?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
-                    ai_codereview?: {
+                    improve_task?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
@@ -68,6 +71,10 @@ export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrches
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
+                    ai_codereview?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
                 } | undefined;
             } | undefined;
         };
@@ -188,12 +195,12 @@ export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrches
         output: import("../../types/index.js").VibingExecution | null;
         meta: object;
     }>;
-    readonly reviewCode: import("@trpc/server").TRPCMutationProcedure<{
+    readonly aiReviewCode: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             taskId: string;
             provider?: string | undefined;
-            model?: string | undefined;
             workflowId?: string | undefined;
+            model?: string | undefined;
             reviewContext?: string | undefined;
         };
         output: {