vibeman 0.0.0 → 0.0.2

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

@@ -0,0 +1,141 @@
+import type { TaskService } from '../../tasks/task-service.js';
+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;
+            tags?: string[] | undefined;
+            priority?: "high" | "medium" | "low" | undefined;
+            search?: string | undefined;
+            includeDeleted?: boolean | undefined;
+            onlyDeleted?: boolean | undefined;
+        } | undefined;
+        output: import("../../types/index.js").Task[];
+        meta: object;
+    }>;
+    readonly getTask: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    readonly createTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            title: string;
+            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+            content: string;
+            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+            id?: string | undefined;
+            tags?: string[] | undefined;
+            due_date?: string | undefined;
+            assignee?: string[] | undefined;
+            priority?: "high" | "medium" | "low" | undefined;
+            comments?: string[] | undefined;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    readonly updateTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            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?: "high" | "medium" | "low" | undefined;
+            comments?: string[] | undefined;
+            content?: string | undefined;
+            deleted_at?: string | undefined;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    readonly deleteTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly moveTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            status: "review" | "in-progress" | "backlog" | "done";
+            id: string;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    readonly getTaskStats: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: any;
+        meta: object;
+    }>;
+    readonly searchTasks: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query: string;
+            includeDeleted?: boolean | undefined;
+            onlyDeleted?: boolean | undefined;
+        };
+        output: import("../../types/index.js").Task[];
+        meta: object;
+    }>;
+    readonly healthCheck: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            status: string;
+            timestamp: string;
+            tasksLoaded: number;
+        };
+        meta: object;
+    }>;
+    readonly onTaskUpdate: import("@trpc/server").TRPCSubscriptionProcedure<{
+        input: {
+            taskId?: string | undefined;
+        } | undefined;
+        output: AsyncIterable<{
+            type: "update" | "delete";
+            taskId: string;
+            task?: any;
+        }, void, any>;
+        meta: object;
+    }>;
+    readonly getTaskHistory: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+            limit?: number | undefined;
+        };
+        output: {
+            available: boolean;
+            history: import("../../vcs/git-history-service.js").TaskHistoryEntry[];
+            error?: undefined;
+        } | {
+            available: boolean;
+            history: never[];
+            error: string;
+        };
+        meta: object;
+    }>;
+    readonly getTaskVersion: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+            commitHash: string;
+        };
+        output: import("../../vcs/git-history-service.js").TaskFileContent;
+        meta: object;
+    }>;
+    readonly getTaskDiff: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+            fromHash: string;
+            toHash: string;
+        };
+        output: import("../../vcs/git-history-service.js").TaskDiffEntry;
+        meta: object;
+    }>;
+};

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

@@ -0,0 +1,238 @@
+import { z } from 'zod';
+import { on, EventEmitter } from 'events';
+import path from 'path';
+import { publicProcedure, TaskCreateSchema, TaskUpdateSchema, TaskFilterSchema } from '../trpc.js';
+import { GitHistoryService } from '../../vcs/git-history-service.js';
+import { getVibeDir } from '../../lib/server/project-root.js';
+export function buildTaskRoutes(taskService, gitService) {
+    const gitHistoryService = new GitHistoryService();
+    return {
+        // Get all tasks with optional filtering
+        listTasks: publicProcedure.input(TaskFilterSchema.optional()).query(async ({ input }) => {
+            await taskService.ensureInitialized();
+            let tasks = taskService.getAllTasks();
+            if (input) {
+                if (input.status)
+                    tasks = tasks.filter((task) => task.status === input.status);
+                if (input.type)
+                    tasks = tasks.filter((task) => task.type === input.type);
+                if (input.priority)
+                    tasks = tasks.filter((task) => task.priority === input.priority);
+                if (input.tags && input.tags.length > 0) {
+                    tasks = tasks.filter((task) => input.tags.some((tag) => task.tags.includes(tag)));
+                }
+                if (input.search)
+                    tasks = taskService.searchTasks(input.search);
+            }
+            if (input?.onlyDeleted) {
+                tasks = tasks.filter((t) => !!t.deleted_at);
+            }
+            else if (!input?.includeDeleted) {
+                tasks = tasks.filter((t) => !t.deleted_at);
+            }
+            return tasks;
+        }),
+        // Get single task by ID
+        getTask: publicProcedure.input(z.object({ id: z.string() })).query(async ({ input }) => {
+            const task = taskService.getTask(input.id);
+            if (!task)
+                throw new Error(`Task ${input.id} not found`);
+            return task;
+        }),
+        // Create new task
+        createTask: publicProcedure.input(TaskCreateSchema).mutation(async ({ input }) => {
+            const newTask = await taskService.createTask(input);
+            try {
+                if (gitService) {
+                    const message = `Create ${newTask.id}: ${newTask.title}`;
+                    const taskFilePath = path.relative(process.cwd(), path.join(getVibeDir(), 'tasks', `${newTask.id}.md`));
+                    await gitService.commitChanges(newTask, message, [taskFilePath]);
+                }
+            }
+            catch {
+                // Non-fatal: ignore commit failure
+            }
+            return newTask;
+        }),
+        // Update existing task
+        updateTask: publicProcedure.input(TaskUpdateSchema).mutation(async ({ input }) => {
+            const { id, ...updates } = input;
+            return await taskService.updateTask(id, updates);
+        }),
+        // Delete task (soft delete + optional git commit)
+        deleteTask: publicProcedure.input(z.object({ id: z.string() })).mutation(async ({ input }) => {
+            await taskService.deleteTask(input.id);
+            try {
+                if (gitService) {
+                    const t = taskService.getTask(input.id);
+                    if (t) {
+                        const message = `Delete ${t.id}: ${t.title}`;
+                        const taskFilePath = path.relative(process.cwd(), path.join(getVibeDir(), 'tasks', `${t.id}.md`));
+                        await gitService.commitChanges(t, message, [taskFilePath]);
+                    }
+                }
+            }
+            catch {
+                // Non-fatal
+            }
+            return { success: true };
+        }),
+        // Move task to different status
+        moveTask: publicProcedure
+            .input(z.object({ id: z.string(), status: z.enum(['backlog', 'in-progress', 'review', 'done']) }))
+            .mutation(async ({ input }) => {
+            const tsk = taskService.getTask(input.id);
+            if (!tsk)
+                throw new Error(`Task ${input.id} not found`);
+            if (tsk.deleted_at)
+                throw new Error(`Task ${input.id} is deleted`);
+            const oldStatus = tsk.status;
+            const updated = await taskService.moveTask(input.id, input.status);
+            try {
+                if (gitService) {
+                    const message = `chore: Update task ${tsk.id} status from ${oldStatus} to ${input.status}`;
+                    const taskFilePath = path.relative(process.cwd(), path.join(getVibeDir(), 'tasks', `${tsk.id}.md`));
+                    await gitService.commitChanges(updated, message, [taskFilePath]);
+                }
+            }
+            catch {
+                // Non-fatal
+            }
+            return updated;
+        }),
+        // Get task statistics
+        getTaskStats: publicProcedure.query(async () => {
+            const tasks = taskService.getAllTasks().filter((t) => !t.deleted_at);
+            const stats = {
+                total: tasks.length,
+                backlog: 0,
+                'in-progress': 0,
+                review: 0,
+                done: 0,
+                byType: {},
+                byPriority: {},
+            };
+            for (const task of tasks) {
+                stats[task.status]++;
+                stats.byType[task.type] = (stats.byType[task.type] || 0) + 1;
+                stats.byPriority[task.priority] = (stats.byPriority[task.priority] || 0) + 1;
+            }
+            return stats;
+        }),
+        // Search tasks
+        searchTasks: publicProcedure
+            .input(z.object({
+            query: z.string(),
+            includeDeleted: z.boolean().optional(),
+            onlyDeleted: z.boolean().optional(),
+        }))
+            .query(async ({ input }) => {
+            let results = taskService.searchTasks(input.query);
+            if (input.onlyDeleted)
+                results = results.filter((t) => !!t.deleted_at);
+            else if (!input.includeDeleted)
+                results = results.filter((t) => !t.deleted_at);
+            return results;
+        }),
+        // Health check
+        healthCheck: publicProcedure.query(async () => {
+            return {
+                status: 'ok',
+                timestamp: new Date().toISOString(),
+                tasksLoaded: taskService.getAllTasks().length,
+            };
+        }),
+        // Subscriptions for task updates
+        onTaskUpdate: publicProcedure
+            .input(z.object({ taskId: z.string().optional() }).optional())
+            .subscription(async function* (opts) {
+            const input = opts.input;
+            const proxy = new EventEmitter();
+            const handleTaskUpdated = (task) => {
+                if (!input?.taskId || task.id === input.taskId) {
+                    proxy.emit('data', { type: 'update', taskId: task.id, task });
+                }
+            };
+            const handleTaskDeleted = (taskId) => {
+                if (!input?.taskId || taskId === input.taskId) {
+                    proxy.emit('data', { type: 'delete', taskId });
+                }
+            };
+            taskService.on('taskUpdated', handleTaskUpdated);
+            taskService.on('taskDeleted', handleTaskDeleted);
+            try {
+                for await (const [payload] of on(proxy, 'data', { signal: opts.signal })) {
+                    yield payload;
+                }
+            }
+            finally {
+                taskService.off('taskUpdated', handleTaskUpdated);
+                taskService.off('taskDeleted', handleTaskDeleted);
+            }
+        }),
+        // Task History procedures
+        getTaskHistory: publicProcedure
+            .input(z.object({
+            taskId: z.string(),
+            limit: z.number().min(1).max(100).default(50),
+        }))
+            .query(async ({ input }) => {
+            const { taskId, limit } = input;
+            // Check if Git repository is available
+            const isGitAvailable = await gitHistoryService.isGitRepositoryAvailable();
+            if (!isGitAvailable) {
+                return { available: false, history: [] };
+            }
+            try {
+                const history = await gitHistoryService.getTaskHistory(taskId, limit);
+                return { available: true, history };
+            }
+            catch (error) {
+                return {
+                    available: false,
+                    history: [],
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+        }),
+        getTaskVersion: publicProcedure
+            .input(z.object({
+            taskId: z.string(),
+            commitHash: z.string(),
+        }))
+            .query(async ({ input }) => {
+            const { taskId, commitHash } = input;
+            const isGitAvailable = await gitHistoryService.isGitRepositoryAvailable();
+            if (!isGitAvailable) {
+                throw new Error('Git repository not available');
+            }
+            try {
+                const version = await gitHistoryService.getTaskVersionContent(taskId, commitHash);
+                return version;
+            }
+            catch (error) {
+                throw new Error(`Failed to get task version: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }),
+        getTaskDiff: publicProcedure
+            .input(z.object({
+            taskId: z.string(),
+            fromHash: z.string(),
+            toHash: z.string(),
+        }))
+            .query(async ({ input }) => {
+            const { taskId, fromHash, toHash } = input;
+            const isGitAvailable = await gitHistoryService.isGitRepositoryAvailable();
+            if (!isGitAvailable) {
+                throw new Error('Git repository not available');
+            }
+            try {
+                const diff = await gitHistoryService.getTaskDiff(taskId, fromHash, toHash);
+                return diff;
+            }
+            catch (error) {
+                throw new Error(`Failed to get task diff: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }),
+    };
+}

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

@@ -0,0 +1,267 @@
+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;
+                    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;
+                    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 {};