vibeman 0.0.3 → 0.0.6

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

@@ -1,275 +0,0 @@
-import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
-type Deps = {
-    vibingOrchestrator: VibingOrchestrator;
-};
-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;
-                stepByStepMode?: boolean | undefined;
-                autoMerge?: boolean | undefined;
-                aiCodeReview?: boolean | undefined;
-                aiRoutingOverrides?: {
-                    execute_task?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                    quality_checks?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                    improve_task?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                    ai_merge?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                    ai_codereview?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                } | undefined;
-            };
-        };
-        output: {
-            readonly success: true;
-        };
-        meta: object;
-    }>;
-    readonly startWorkflow: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            taskId: string;
-            config?: {
-                autoCommit?: boolean | undefined;
-                createPR?: boolean | undefined;
-                autoQualityChecks?: boolean | undefined;
-                requireHumanApproval?: boolean | undefined;
-                stepByStepMode?: boolean | undefined;
-                autoMerge?: boolean | undefined;
-                aiCodeReview?: boolean | undefined;
-                aiRoutingOverrides?: {
-                    execute_task?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                    quality_checks?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                    improve_task?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                    ai_merge?: {
-                        provider?: string | undefined;
-                        model?: string | undefined;
-                    } | undefined;
-                    ai_codereview?: {
-                        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 aiReviewCode: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            taskId: string;
-            provider?: string | undefined;
-            workflowId?: string | undefined;
-            model?: 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

@@ -1,311 +0,0 @@
-import { z } from 'zod';
-import { on, EventEmitter } from 'events';
-import { publicProcedure } from '../trpc.js';
-import { TRPCError } from '@trpc/server';
-export function buildWorkflowRoutes({ vibingOrchestrator }) {
-    const OperationOverrideSchema = z.object({
-        provider: z.string().optional(),
-        model: z.string().optional(),
-    });
-    const WorkflowAIRoutingOverrides = z
-        .object({
-        execute_task: OperationOverrideSchema.optional(),
-        quality_checks: OperationOverrideSchema.optional(),
-        ai_codereview: OperationOverrideSchema.optional(),
-        ai_merge: OperationOverrideSchema.optional(),
-        improve_task: 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 = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            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 = vibingOrchestrator;
-                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 = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            await orchestrator.runCleanup(input.workflowId);
-            return { success: true };
-        }),
-        pauseWorkflow: publicProcedure
-            .input(z.object({ workflowId: z.string() }))
-            .mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            await orchestrator.approveWorkflow(input.workflowId);
-            return { success: true };
-        }),
-        rejectWorkflow: publicProcedure
-            .input(z.object({ workflowId: z.string(), feedback: z.string() }))
-            .mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            return orchestrator.getWorkflow(input.workflowId);
-        }),
-        getWorkflowsByTaskId: publicProcedure
-            .input(z.object({ taskId: z.string() }))
-            .query(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            return orchestrator.getTaskWorkflows(input.taskId);
-        }),
-        getLatestWorkflowByTaskId: publicProcedure
-            .input(z.object({ taskId: z.string() }))
-            .query(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            return orchestrator.getLatestWorkflowByTask(input.taskId);
-        }),
-        aiReviewCode: 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 = vibingOrchestrator;
-            const overrides = input.provider || input.model
-                ? { provider: input.provider, model: input.model }
-                : undefined;
-            return await orchestrator.aiReviewCode(input.taskId, input.reviewContext, {
-                workflowId: input.workflowId,
-                overrides,
-            });
-        }),
-        approveAndContinueReview: publicProcedure
-            .input(z.object({ workflowId: z.string() }))
-            .mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            await orchestrator.approveAndContinueReview(input.workflowId);
-            return { success: true };
-        }),
-        markCompleted: publicProcedure
-            .input(z.object({ workflowId: z.string() }))
-            .mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            await orchestrator.markWorkflowCompleted(input.workflowId);
-            return { success: true };
-        }),
-        checkWorktreeStatus: publicProcedure
-            .input(z.object({ workflowId: z.string() }))
-            .mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            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 = vibingOrchestrator;
-            await orchestrator.rerunPhase(input.workflowId, input.phase);
-            return { success: true };
-        }),
-    };
-}

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

@@ -1,101 +0,0 @@
-import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
-type Deps = {
-    vibingOrchestrator: VibingOrchestrator;
-};
-export declare function buildWorktreeRoutes({ vibingOrchestrator }: 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;
-            taskId?: string | undefined;
-            force?: boolean | undefined;
-            worktreePath?: string | undefined;
-            branchName?: string | undefined;
-        };
-        output: {
-            readonly success: true;
-        };
-        meta: object;
-    }>;
-};
-export {};