vibeman 0.0.1 → 0.0.3

package/dist/runtime/api/lib/server/bootstrap.js

@@ -0,0 +1,197 @@
+/**
+ * Server Bootstrap - Async-first service initialization
+ *
+ * Provides ordered initialization of core services before router creation,
+ * ensuring all dependencies are ready for synchronous access during runtime.
+ */
+import { log } from '../logger.js';
+import { getSettingsService } from '../../settings-service.js';
+import { TaskService } from '../../tasks/task-service.js';
+import { AgentService } from '../../agent/agent-service.js';
+import { GitService } from '../../vcs/git-service.js';
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+import { getProjectRoot, getVibeDir } from './project-root.js';
+// Ready-only service instances - throw if accessed before bootstrap
+let settingsService = null;
+let taskService = null;
+let agentService = null;
+let gitService = null;
+let worktreeService = null;
+let vibingOrchestrator = null;
+// Bootstrap completion promise for diagnostics/tests
+let ready = null;
+let isBootstrapped = false;
+// Default config fallback for VibingOrchestrator
+const getDefaultVibingConfig = () => ({
+    autoQualityChecks: true,
+    requireHumanApproval: true,
+    aiCodeReview: true,
+    retryPolicy: { maxImplementationAttempts: 3 },
+    autoCommit: false,
+});
+/**
+ * Initialize core services in proper dependency order.
+ * Must be called before any service getters or router creation.
+ */
+export async function bootstrap() {
+    if (isBootstrapped) {
+        log.info('Bootstrap already completed, skipping');
+        return;
+    }
+    if (ready) {
+        log.info('Bootstrap already in progress, waiting...');
+        return ready;
+    }
+    const startTime = Date.now();
+    log.info('Starting server bootstrap', {}, 'bootstrap');
+    ready = (async () => {
+        try {
+            // Stage 1: Settings Service (foundation)
+            const settingsStart = Date.now();
+            settingsService = getSettingsService();
+            log.info('Settings service initialized', {
+                duration: Date.now() - settingsStart,
+            }, 'bootstrap');
+            // Stage 2: Task Service (depends on settings for vibeDir)
+            const taskStart = Date.now();
+            const settingsVibeDir = (() => {
+                try {
+                    const s = settingsService.getSettings();
+                    return s?.development?.vibeDir;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            const vibeDir = settingsVibeDir ?? getVibeDir();
+            taskService = new TaskService(vibeDir);
+            await taskService.ensureInitialized();
+            log.info('Task service initialized', {
+                vibeDir,
+                duration: Date.now() - taskStart,
+            }, 'bootstrap');
+            // Stage 3: Git Service (independent)
+            const gitStart = Date.now();
+            const projectRoot = getProjectRoot();
+            const settingsDefaultBranch = (() => {
+                try {
+                    const s = settingsService.getSettings();
+                    return s?.development?.git?.defaultBranch;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            const gitConfig = {
+                defaultBranch: settingsDefaultBranch || 'main',
+            };
+            gitService = new GitService(projectRoot, gitConfig);
+            log.info('Git service initialized', {
+                projectRoot,
+                defaultBranch: gitConfig.defaultBranch,
+                duration: Date.now() - gitStart,
+            }, 'bootstrap');
+            // Stage 4: Agent Service (depends on task service)
+            const agentStart = Date.now();
+            agentService = new AgentService(taskService, projectRoot);
+            log.info('Agent service initialized', {
+                duration: Date.now() - agentStart,
+            }, 'bootstrap');
+            // Stage 5: Worktree Service (depends on git service, settings)
+            const worktreeStart = Date.now();
+            worktreeService = agentService.getWorktreeService();
+            await worktreeService.initialize();
+            log.info('Worktree service initialized', {
+                duration: Date.now() - worktreeStart,
+            }, 'bootstrap');
+            // Stage 6: VibingOrchestrator (depends on all previous services)
+            const orchestratorStart = Date.now();
+            vibingOrchestrator = new VibingOrchestrator(taskService, agentService, worktreeService, getDefaultVibingConfig(), gitService);
+            await vibingOrchestrator.initialize();
+            log.info('VibingOrchestrator initialized', {
+                duration: Date.now() - orchestratorStart,
+            }, 'bootstrap');
+            isBootstrapped = true;
+            const totalDuration = Date.now() - startTime;
+            log.info('Server bootstrap completed', {
+                totalDuration,
+                stages: 6,
+            }, 'bootstrap');
+        }
+        catch (error) {
+            log.error('Server bootstrap failed', error, 'bootstrap');
+            throw error;
+        }
+    })();
+    return ready;
+}
+/**
+ * Ready-only sync getters - throw if called before bootstrap
+ */
+export function getBootstrappedSettingsService() {
+    if (!settingsService) {
+        throw new Error('Settings service not available - bootstrap() must be called first');
+    }
+    return settingsService;
+}
+export function getBootstrappedTaskService() {
+    if (!taskService) {
+        throw new Error('Task service not available - bootstrap() must be called first');
+    }
+    return taskService;
+}
+export function getBootstrappedAgentService() {
+    if (!agentService) {
+        throw new Error('Agent service not available - bootstrap() must be called first');
+    }
+    return agentService;
+}
+export function getBootstrappedGitService() {
+    if (!gitService) {
+        throw new Error('Git service not available - bootstrap() must be called first');
+    }
+    return gitService;
+}
+export function getBootstrappedWorktreeService() {
+    if (!worktreeService) {
+        throw new Error('Worktree service not available - bootstrap() must be called first');
+    }
+    return worktreeService;
+}
+export function getBootstrappedVibingOrchestrator() {
+    if (!vibingOrchestrator) {
+        throw new Error('VibingOrchestrator not available - bootstrap() must be called first');
+    }
+    return vibingOrchestrator;
+}
+/**
+ * Get bootstrap completion promise for diagnostics/tests
+ */
+export function getBootstrapReady() {
+    return ready;
+}
+/**
+ * Check if bootstrap has completed
+ */
+export function isBootstrapComplete() {
+    return isBootstrapped;
+}
+/**
+ * Test bootstrap function that initializes against a temp workspace
+ */
+export async function testBootstrap(tempWorkspace) {
+    // Reset bootstrap state for testing
+    settingsService = null;
+    taskService = null;
+    agentService = null;
+    gitService = null;
+    worktreeService = null;
+    vibingOrchestrator = null;
+    ready = null;
+    isBootstrapped = false;
+    // TODO: Implement temp workspace logic if needed
+    if (tempWorkspace) {
+        log.info('Test bootstrap with temp workspace', { tempWorkspace }, 'bootstrap');
+    }
+    return bootstrap();
+}

package/dist/runtime/api/lib/server/project-root.js

@@ -8,7 +8,30 @@ import path from 'path';
 export function getProjectRoot() {
     const envRoot = process.env.VIBEMAN_PROJECT_ROOT;
     if (envRoot && envRoot.trim().length > 0) {
-        return path.resolve(envRoot);
+        const trimmedRoot = envRoot.trim();
+        if (path.isAbsolute(trimmedRoot)) {
+            return path.normalize(trimmedRoot);
+        }
+        const baseCandidates = [
+            process.env.VIBEMAN_PROJECT_ROOT_BASE,
+            process.env.INIT_CWD,
+            process.env.PWD,
+            process.cwd(),
+        ].filter((candidate) => !!candidate && candidate.trim().length > 0);
+        let fallbackResolved = null;
+        for (const base of baseCandidates) {
+            const resolved = path.resolve(base, trimmedRoot);
+            if (!fallbackResolved) {
+                fallbackResolved = resolved;
+            }
+            if (fs.existsSync(resolved)) {
+                return resolved;
+            }
+        }
+        if (fallbackResolved) {
+            return fallbackResolved;
+        }
+        return path.resolve(trimmedRoot);
     }
     // First preference: directory that contains a .git directory/file
     let dir = process.cwd();

package/dist/runtime/api/lib/trpc/server.d.ts

@@ -4,6 +4,98 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
     transformer: true;
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    detectAllProviders: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, import("../provider-detection.js").DetectionResult>;
+        meta: object;
+    }>;
+    detectProvider: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            provider: string;
+        };
+        output: import("../provider-detection.js").DetectionResult;
+        meta: object;
+    }>;
+    setProviderPath: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            path: string;
+            provider: string;
+        };
+        output: {
+            success: boolean;
+            result: import("../provider-detection.js").DetectionResult;
+        };
+        meta: object;
+    }>;
+    clearProviderPath: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            provider: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    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;
+    }>;
+    clearValidationCache: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    getProviderDiagnostics: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            localConfigPath: string;
+            localConfigExists: boolean;
+            providers: {
+                provider: string;
+                detection: import("../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;
+    }>;
     listProviders: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: {
@@ -25,19 +117,31 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     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;
     }>;
     updateRoutingPolicy: import("@trpc/server").TRPCMutationProcedure<{
         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;
@@ -62,17 +166,17 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     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;
@@ -241,24 +345,25 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     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;
@@ -266,9 +371,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
+                    ai_codereview?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
                 } | undefined;
             };
-            workflowId: string;
         };
         output: {
             readonly success: true;
@@ -279,23 +387,23 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
         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;
@@ -303,6 +411,10 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
+                    ai_codereview?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
                 } | undefined;
             } | undefined;
         };
@@ -423,12 +535,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
         output: import("../../types/index.js").VibingExecution | null;
         meta: object;
     }>;
-    reviewCode: import("@trpc/server").TRPCMutationProcedure<{
+    aiReviewCode: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             taskId: string;
             provider?: string | undefined;
-            model?: string | undefined;
             workflowId?: string | undefined;
+            model?: string | undefined;
             reviewContext?: string | undefined;
         };
         output: {
@@ -583,9 +695,9 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     cleanupWorktree: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             isConnectedToTask: boolean;
-            worktreePath?: string | undefined;
-            force?: boolean | undefined;
             taskId?: string | undefined;
+            force?: boolean | undefined;
+            worktreePath?: string | undefined;
             branchName?: string | undefined;
         };
         output: {
@@ -653,9 +765,9 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     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;
@@ -664,6 +776,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             type: string;
             priority: string;
             content: string;
+            title?: string;
             executionId: string;
             selectedModel?: string;
         };
@@ -683,11 +796,11 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     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;
@@ -703,15 +816,15 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     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;
@@ -720,13 +833,13 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     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;
@@ -745,7 +858,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     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/lib/trpc/server.js

@@ -1,11 +1,11 @@
 import { createRouter } from '../../router.js';
-import { getTaskService } from '../server/task-service-singleton.js';
-import { getGitService } from '../server/git-service-singleton.js';
-import { getVibingOrchestrator, getVibingOrchestratorAsync, } from '../server/vibing-orchestrator-singleton.js';
+import { bootstrap, getBootstrappedTaskService, getBootstrappedGitService, getBootstrappedVibingOrchestrator, } from '../server/bootstrap.js';
 // Build the application router for use by the standalone API server.
 // Note: This module no longer starts any WebSocket servers automatically.
-// Runtime bootstrapping happens in the API server entrypoint.
-const taskService = getTaskService();
-const gitService = getGitService();
-const workflowOrchestrator = getVibingOrchestrator();
-export const appRouter = createRouter(taskService, gitService, workflowOrchestrator, getVibingOrchestratorAsync);
+// Services must be bootstrapped before calling this.
+// Ensure bootstrap is complete before creating router
+await bootstrap();
+const taskService = getBootstrappedTaskService();
+const gitService = getBootstrappedGitService();
+const workflowOrchestrator = getBootstrappedVibingOrchestrator();
+export const appRouter = createRouter(taskService, gitService, workflowOrchestrator);

package/dist/runtime/api/lib/trpc/ws-server.js

@@ -5,9 +5,9 @@ export function startTRPCWebSocketServer(router) {
     if (typeof global.__VIBEMAN_WSS__ === 'object' && global.__VIBEMAN_WSS__?.started) {
         return; // already started
     }
-    // Decide WS port: prefer explicit env; else (+1) from HTTP port
+    // Decide WS port: (+1) from HTTP port
     const httpPort = Number(process.env.PORT || 3000);
-    const wsPort = Number(process.env.NEXT_PUBLIC_VIBEMAN_WS_PORT || process.env.VIBEMAN_WS_PORT || httpPort + 1);
+    const wsPort = httpPort + 1;
     try {
         const wss = new WebSocketServer({ port: wsPort, path: '/api/trpc' });
         // Handle binding errors gracefully (e.g., EADDRINUSE across HMR workers)