vibeman 0.0.0 → 0.0.1

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { publicProcedure } from '../trpc.js';
+import { makeAssertTaskActive } from '../router-helpers.js';
+export function buildGitRoutes(taskService, gitService) {
+    const assertTaskActive = makeAssertTaskActive(taskService);
+    return {
+        getGitStatus: publicProcedure.query(async () => {
+            return await gitService.getStatus();
+        }),
+        createBranch: publicProcedure
+            .input(z.object({ taskId: z.string(), baseBranch: z.string().optional() }))
+            .mutation(async ({ input }) => {
+            const task = assertTaskActive(input.taskId);
+            return await gitService.createBranch(task, input.baseBranch);
+        }),
+        commitChanges: publicProcedure
+            .input(z.object({
+            taskId: z.string(),
+            message: z.string().optional(),
+            files: z.array(z.string()).optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const task = assertTaskActive(input.taskId);
+            return await gitService.commitChanges(task, input.message, input.files);
+        }),
+        getCommitHistory: publicProcedure
+            .input(z.object({ maxCount: z.number().optional() }))
+            .query(async ({ input }) => {
+            return await gitService.getCommitHistory(input.maxCount);
+        }),
+        hasUncommittedChanges: publicProcedure.query(async () => {
+            return await gitService.hasUncommittedChanges();
+        }),
+    };
+}

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

@@ -0,0 +1,139 @@
+/**
+ * tRPC routes for settings management
+ */
+export declare function buildSettingsRoutes(): {
+    /**
+     * Get current settings
+     */
+    getSettings: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../../types/settings.js").VibemanSettings;
+        meta: object;
+    }>;
+    /**
+     * Detect quality checks using AI and persist them into settings
+     */
+    detectQualityChecks: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            checks: {
+                name: string;
+                command: string;
+                args: string[];
+                timeout: number;
+                enabled: boolean;
+            }[];
+            workingDirectory: string;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get a specific setting by path
+     */
+    getSetting: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            path: string[];
+        };
+        output: unknown;
+        meta: object;
+    }>;
+    /**
+     * Update multiple settings
+     */
+    updateSettings: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            path: string[];
+            value?: unknown;
+        }[];
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    /**
+     * Reset settings to defaults
+     */
+    resetToDefaults: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: import("../../types/settings.js").VibemanSettings;
+        meta: object;
+    }>;
+    /**
+     * Validate settings schema
+     */
+    validateSettings: import("@trpc/server").TRPCQueryProcedure<{
+        input: Record<string, unknown>;
+        output: {
+            valid: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    /**
+     * Get settings file information
+     */
+    getSettingsInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            path: string;
+            exists: boolean;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get available editor presets
+     */
+    getEditorPresets: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, Partial<{
+            type?: "vscode" | "cursor" | "vim" | "custom";
+            command?: string;
+            args?: string[];
+            name?: string;
+            openFileCommand?: string[];
+            openFolderCommand?: string[];
+        } | undefined>>;
+        meta: object;
+    }>;
+    /**
+     * Get available terminal presets
+     */
+    getTerminalPresets: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, Partial<{
+            type?: "system" | "iterm2" | "warp" | "custom";
+            command?: string;
+            args?: string[];
+            name?: string;
+            openCommand?: string[];
+        } | undefined>>;
+        meta: object;
+    }>;
+    /**
+     * Apply editor preset configuration
+     */
+    applyEditorPreset: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            presetName: string;
+        };
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    /**
+     * Apply terminal preset configuration
+     */
+    applyTerminalPreset: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            presetName: string;
+        };
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+};

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

@@ -0,0 +1,113 @@
+/**
+ * tRPC routes for settings management
+ */
+import { z } from 'zod';
+import { publicProcedure } from '../trpc.js';
+import { getSettingsService } from '../../settings-service.js';
+import { QualityPipeline } from '../../workflows/quality-pipeline.js';
+import { getProjectRoot } from '../../lib/server/project-root.js';
+// Input validation schemas
+const UpdateSettingsInputSchema = z.array(z.object({
+    path: z.array(z.string().min(1)),
+    value: z.unknown(),
+}));
+export function buildSettingsRoutes() {
+    const settingsService = getSettingsService();
+    // Initialize settings service on first router build
+    settingsService.initialize().catch(console.error);
+    return {
+        /**
+         * Get current settings
+         */
+        getSettings: publicProcedure.query(async () => {
+            await settingsService.initialize();
+            return settingsService.getSettings();
+        }),
+        /**
+         * Detect quality checks using AI and persist them into settings
+         */
+        detectQualityChecks: publicProcedure.mutation(async () => {
+            // TODO: Integrate this into the onboarding flow to auto-bootstrap
+            // quality checks on first project setup.
+            await settingsService.initialize();
+            const pipeline = new QualityPipeline();
+            const workingDirectory = getProjectRoot();
+            const checks = await pipeline.detectAndPersistChecks(workingDirectory);
+            return { checks, workingDirectory };
+        }),
+        /**
+         * Get a specific setting by path
+         */
+        getSetting: publicProcedure
+            .input(z.object({ path: z.array(z.string().min(1)) }))
+            .query(async ({ input }) => {
+            await settingsService.initialize();
+            return settingsService.getSetting(input.path);
+        }),
+        /**
+         * Update multiple settings
+         */
+        updateSettings: publicProcedure.input(UpdateSettingsInputSchema).mutation(async ({ input }) => {
+            await settingsService.initialize();
+            const updates = input.map((item) => ({
+                path: item.path,
+                value: item.value,
+            }));
+            return await settingsService.updateSettings(updates);
+        }),
+        /**
+         * Reset settings to defaults
+         */
+        resetToDefaults: publicProcedure.mutation(async () => {
+            await settingsService.initialize();
+            await settingsService.resetToDefaults();
+            return settingsService.getSettings();
+        }),
+        /**
+         * Validate settings schema
+         */
+        validateSettings: publicProcedure.input(z.record(z.unknown())).query(async ({ input }) => {
+            await settingsService.initialize();
+            return settingsService.validateSettings(input);
+        }),
+        /**
+         * Get settings file information
+         */
+        getSettingsInfo: publicProcedure.query(async () => {
+            await settingsService.initialize();
+            return settingsService.getSettingsInfo();
+        }),
+        /**
+         * Get available editor presets
+         */
+        getEditorPresets: publicProcedure.query(async () => {
+            await settingsService.initialize();
+            return settingsService.getEditorPresets();
+        }),
+        /**
+         * Get available terminal presets
+         */
+        getTerminalPresets: publicProcedure.query(async () => {
+            await settingsService.initialize();
+            return settingsService.getTerminalPresets();
+        }),
+        /**
+         * Apply editor preset configuration
+         */
+        applyEditorPreset: publicProcedure
+            .input(z.object({ presetName: z.string().min(1) }))
+            .mutation(async ({ input }) => {
+            await settingsService.initialize();
+            return await settingsService.applyEditorPreset(input.presetName);
+        }),
+        /**
+         * Apply terminal preset configuration
+         */
+        applyTerminalPreset: publicProcedure
+            .input(z.object({ presetName: z.string().min(1) }))
+            .mutation(async ({ input }) => {
+            await settingsService.initialize();
+            return await settingsService.applyTerminalPreset(input.presetName);
+        }),
+    };
+}

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: {
+            type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
+            search?: string | undefined;
+            tags?: 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: {
+            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+            title: string;
+            content: string;
+            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
+            id?: string | undefined;
+            tags?: string[] | undefined;
+            due_date?: string | undefined;
+            assignee?: string[] | undefined;
+            comments?: string[] | undefined;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    readonly updateTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
+            title?: string | undefined;
+            tags?: string[] | undefined;
+            due_date?: string | undefined;
+            assignee?: string[] | 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: "backlog" | "in-progress" | "review" | "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'}`);
+            }
+        }),
+    };
+}