vibeman 0.0.0 → 0.0.1

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

@@ -0,0 +1,268 @@
+import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+type Deps = {
+    requireOrchestrator: () => Promise<VibingOrchestrator>;
+    requireOrchestratorSync: () => VibingOrchestrator;
+};
+export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSync }: Deps): {
+    readonly updateWorkflowOptions: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            config: {
+                autoQualityChecks?: boolean | undefined;
+                requireHumanApproval?: boolean | undefined;
+                aiCodeReview?: boolean | undefined;
+                autoCommit?: boolean | undefined;
+                stepByStepMode?: boolean | undefined;
+                createPR?: boolean | undefined;
+                autoMerge?: boolean | undefined;
+                aiRoutingOverrides?: {
+                    execute_task?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    improve_task?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    ai_codereview?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    ai_merge?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly startWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            config?: {
+                autoQualityChecks?: boolean | undefined;
+                requireHumanApproval?: boolean | undefined;
+                aiCodeReview?: boolean | undefined;
+                autoCommit?: boolean | undefined;
+                stepByStepMode?: boolean | undefined;
+                createPR?: boolean | undefined;
+                autoMerge?: boolean | undefined;
+                aiRoutingOverrides?: {
+                    execute_task?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    improve_task?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    ai_codereview?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    ai_merge?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                } | undefined;
+            } | undefined;
+        };
+        output: {
+            workflowId: string;
+        };
+        meta: object;
+    }>;
+    readonly continueWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly runValidation: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly runMerge: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            provider?: string | undefined;
+            model?: string | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly runCleanup: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly pauseWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly resetWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            force?: boolean | undefined;
+            deleteWorktree?: boolean | undefined;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    readonly approveWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            comments?: string | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly rejectWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            feedback: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly onTaskWorkflowEvents: import("@trpc/server").TRPCSubscriptionProcedure<{
+        input: {
+            taskId?: string | undefined;
+        } | undefined;
+        output: AsyncIterable<{
+            type: "started" | "phase" | "completed" | "failed" | "updated" | "deleted";
+            workflowId: string;
+            phase?: string;
+            workflow?: any;
+            executionId?: string;
+        }, void, any>;
+        meta: object;
+    }>;
+    readonly getWorkflow: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: import("../../types/index.js").VibingExecution | null;
+        meta: object;
+    }>;
+    readonly getWorkflowsByTaskId: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: import("../../types/index.js").VibingExecution[];
+        meta: object;
+    }>;
+    readonly getLatestWorkflowByTaskId: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: import("../../types/index.js").VibingExecution | null;
+        meta: object;
+    }>;
+    readonly reviewCode: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            provider?: string | undefined;
+            model?: string | undefined;
+            workflowId?: string | undefined;
+            reviewContext?: string | undefined;
+        };
+        output: {
+            executionId: string;
+            reviewSummary: string;
+            recommendations: string[];
+            qualityScore: number;
+        };
+        meta: object;
+    }>;
+    readonly approveAndContinueReview: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    readonly markCompleted: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    readonly checkWorktreeStatus: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            clean: boolean;
+            uncommittedFiles: string[];
+            worktreePath?: string;
+        };
+        meta: object;
+    }>;
+    readonly rerunImplementation: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            provider?: string | undefined;
+            model?: string | undefined;
+            feedback?: string | undefined;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    readonly skipToNextPhase: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    readonly rerunFromPhase: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            phase: "completed" | "failed" | "draft" | "awaiting-review" | "approved" | "merged" | "paused" | "implementing" | "validating" | "ai-reviewing" | "merging" | "cleaning";
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+};
+export {};

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

@@ -0,0 +1,308 @@
+import { z } from 'zod';
+import { on, EventEmitter } from 'events';
+import { publicProcedure } from '../trpc.js';
+import { TRPCError } from '@trpc/server';
+export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSync }) {
+    const OperationOverrideSchema = z.object({
+        provider: z.string().optional(),
+        model: z.string().optional(),
+    });
+    const WorkflowAIRoutingOverrides = z
+        .object({
+        execute_task: OperationOverrideSchema.optional(),
+        improve_task: OperationOverrideSchema.optional(),
+        ai_codereview: OperationOverrideSchema.optional(),
+        ai_merge: OperationOverrideSchema.optional(),
+    })
+        .partial();
+    const WorkflowConfig = z.object({
+        autoQualityChecks: z.boolean().optional(),
+        requireHumanApproval: z.boolean().optional(),
+        stepByStepMode: z.boolean().optional(),
+        autoCommit: z.boolean().optional(),
+        createPR: z.boolean().optional(),
+        autoMerge: z.boolean().optional(),
+        aiCodeReview: z.boolean().optional(),
+        aiRoutingOverrides: WorkflowAIRoutingOverrides.optional(),
+    });
+    const WorkflowConfigOpt = WorkflowConfig.optional();
+    return {
+        updateWorkflowOptions: publicProcedure
+            .input(z.object({ workflowId: z.string(), config: WorkflowConfig }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.updateWorkflowOptions(input.workflowId, input.config);
+            return { success: true };
+        }),
+        startWorkflow: publicProcedure
+            .input(z.object({ taskId: z.string(), config: WorkflowConfigOpt }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            const workflowId = await orchestrator.startWorkflow(input.taskId, input.config || {});
+            return { workflowId };
+        }),
+        continueWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            try {
+                const orchestrator = await requireOrchestrator();
+                await orchestrator.continueWorkflow(input.workflowId);
+                return { success: true };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error('continueWorkflow failed:', msg);
+                throw new TRPCError({ code: 'BAD_REQUEST', message: msg });
+            }
+        }),
+        runValidation: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.runValidation(input.workflowId);
+            return { success: true };
+        }),
+        runMerge: publicProcedure
+            .input(z.object({
+            workflowId: z.string(),
+            provider: z.string().optional(),
+            model: z.string().optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.runMerge(input.workflowId, {
+                provider: input.provider,
+                model: input.model,
+            });
+            return { success: true };
+        }),
+        runCleanup: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.runCleanup(input.workflowId);
+            return { success: true };
+        }),
+        pauseWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.pauseWorkflow(input.workflowId);
+            return { success: true };
+        }),
+        resetWorkflow: publicProcedure
+            .input(z.object({
+            workflowId: z.string(),
+            deleteWorktree: z.boolean().optional(),
+            force: z.boolean().optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.resetWorkflow(input.workflowId, {
+                deleteWorktree: input.deleteWorktree,
+                force: input.force,
+            });
+            return { success: true };
+        }),
+        approveWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string(), comments: z.string().optional() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.approveWorkflow(input.workflowId);
+            return { success: true };
+        }),
+        rejectWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string(), feedback: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.rejectWorkflow(input.workflowId, input.feedback);
+            return { success: true };
+        }),
+        onTaskWorkflowEvents: publicProcedure
+            .input(z.object({ taskId: z.string().optional() }).optional())
+            .subscription(async function* (opts) {
+            const input = opts.input;
+            const orchestrator = requireOrchestratorSync();
+            const proxy = new EventEmitter();
+            const handleStarted = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'started', workflowId: workflow.id, workflow });
+            };
+            const handlePhaseChanged = (data) => {
+                if (!input?.taskId || data.workflow?.taskId === input.taskId) {
+                    // Dedupe terminal phases: completed/failed are emitted via dedicated events
+                    if (data.newPhase !== 'completed' && data.newPhase !== 'failed') {
+                        proxy.emit('data', {
+                            type: 'phase',
+                            workflowId: data.workflowId,
+                            phase: data.newPhase,
+                            workflow: data.workflow,
+                        });
+                    }
+                }
+            };
+            const handleCompleted = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'completed', workflowId: workflow.id, workflow });
+            };
+            const handleFailed = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'failed', workflowId: workflow.id, workflow });
+            };
+            // New: forward execution start events at the task level
+            const handleExecStarted = (data) => {
+                if (!input?.taskId || data?.workflow?.taskId === input.taskId) {
+                    proxy.emit('data', {
+                        type: 'phase',
+                        workflowId: data.workflowId,
+                        phase: data.phase || data.workflow?.phase,
+                        workflow: data.workflow,
+                        executionId: data.executionId,
+                    });
+                }
+            };
+            // Forward additional workflow lifecycle/snapshot events
+            const handleUpdated = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'updated', workflowId: workflow.id, workflow });
+            };
+            const handleDeleted = (info) => {
+                if (!input?.taskId || info?.taskId === input.taskId)
+                    proxy.emit('data', { type: 'deleted', workflowId: info.workflowId });
+            };
+            const handlePaused = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'updated', workflowId: workflow.id, workflow });
+            };
+            const handleOptionsUpdated = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'updated', workflowId: workflow.id, workflow });
+            };
+            orchestrator.on('workflowStarted', handleStarted);
+            orchestrator.on('workflowPhaseChanged', handlePhaseChanged);
+            orchestrator.on('workflowCompleted', handleCompleted);
+            orchestrator.on('workflowFailed', handleFailed);
+            orchestrator.on('workflowExecutionStarted', handleExecStarted);
+            orchestrator.on('workflowUpdated', handleUpdated);
+            orchestrator.on('workflowDeleted', handleDeleted);
+            orchestrator.on('workflowPaused', handlePaused);
+            orchestrator.on('workflowOptionsUpdated', handleOptionsUpdated);
+            try {
+                for await (const [payload] of on(proxy, 'data', { signal: opts.signal })) {
+                    yield payload;
+                }
+            }
+            finally {
+                orchestrator.off('workflowStarted', handleStarted);
+                orchestrator.off('workflowPhaseChanged', handlePhaseChanged);
+                orchestrator.off('workflowCompleted', handleCompleted);
+                orchestrator.off('workflowFailed', handleFailed);
+                orchestrator.off('workflowExecutionStarted', handleExecStarted);
+                orchestrator.off('workflowUpdated', handleUpdated);
+                orchestrator.off('workflowDeleted', handleDeleted);
+                orchestrator.off('workflowPaused', handlePaused);
+                orchestrator.off('workflowOptionsUpdated', handleOptionsUpdated);
+            }
+        }),
+        // Additional workflow helpers used by UI
+        getWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .query(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            return orchestrator.getWorkflow(input.workflowId);
+        }),
+        getWorkflowsByTaskId: publicProcedure
+            .input(z.object({ taskId: z.string() }))
+            .query(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            return orchestrator.getTaskWorkflows(input.taskId);
+        }),
+        getLatestWorkflowByTaskId: publicProcedure
+            .input(z.object({ taskId: z.string() }))
+            .query(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            return orchestrator.getLatestWorkflowByTask(input.taskId);
+        }),
+        reviewCode: publicProcedure
+            .input(z.object({
+            taskId: z.string(),
+            workflowId: z.string().optional(),
+            reviewContext: z.string().optional(),
+            provider: z.string().optional(),
+            model: z.string().optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            return await orchestrator.reviewCode(input.taskId, input.reviewContext, {
+                workflowId: input.workflowId,
+                provider: input.provider,
+                model: input.model,
+            });
+        }),
+        approveAndContinueReview: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.approveAndContinueReview(input.workflowId);
+            return { success: true };
+        }),
+        markCompleted: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.markWorkflowCompleted(input.workflowId);
+            return { success: true };
+        }),
+        checkWorktreeStatus: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            return await orchestrator.checkWorktreeStatus(input.workflowId);
+        }),
+        rerunImplementation: publicProcedure
+            .input(z.object({
+            workflowId: z.string(),
+            feedback: z.string().optional(),
+            provider: z.string().optional(),
+            model: z.string().optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.rerunImplementation(input.workflowId, input.feedback, {
+                provider: input.provider,
+                model: input.model,
+            });
+            return { success: true };
+        }),
+        skipToNextPhase: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.skipToNextPhase(input.workflowId);
+            return { success: true };
+        }),
+        rerunFromPhase: publicProcedure
+            .input(z.object({
+            workflowId: z.string(),
+            phase: z.enum([
+                'draft',
+                'implementing',
+                'validating',
+                'ai-reviewing',
+                'awaiting-review',
+                'paused',
+                'approved',
+                'merging',
+                'merged',
+                'cleaning',
+                'completed',
+                'failed',
+            ]),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.rerunPhase(input.workflowId, input.phase);
+            return { success: true };
+        }),
+    };
+}

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

@@ -0,0 +1,102 @@
+import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+type Deps = {
+    requireOrchestrator: () => Promise<VibingOrchestrator>;
+    requireOrchestratorSync: () => VibingOrchestrator;
+};
+export declare function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSync }: Deps): {
+    readonly listWorktrees: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: (import("../../types/index.js").WorktreeInfo & {
+            isConnectedToTask: boolean;
+        })[];
+        meta: object;
+    }>;
+    readonly syncWorktreeState: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            readonly success: true;
+            readonly message: "Worktree state synchronized";
+        };
+        meta: object;
+    }>;
+    readonly getWorktreeInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    readonly createWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    readonly deleteWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            force?: boolean | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly openInEditor: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worktreePath: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly openInTerminal: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worktreePath: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly createWorktreePR: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            baseBranch?: string | undefined;
+        };
+        output: {
+            success: boolean;
+            pullRequest?: any;
+            error?: string;
+        };
+        meta: object;
+    }>;
+    readonly createPullRequest: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            baseBranch?: string | undefined;
+        };
+        output: {
+            success: boolean;
+            pullRequest?: any;
+            error?: string;
+        };
+        meta: object;
+    }>;
+    readonly cleanupWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            isConnectedToTask: boolean;
+            worktreePath?: string | undefined;
+            force?: boolean | undefined;
+            taskId?: string | undefined;
+            branchName?: string | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+};
+export {};