vibeman 0.0.5 → 0.0.6

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

@@ -1,129 +0,0 @@
-/**
- * tRPC routes for settings management
- */
-import path from 'path';
-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';
-import { getVibemanInfo } from '../../lib/server/vibeman-info.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 project information
-         */
-        getProjectInfo: publicProcedure.query(async () => {
-            const root = getProjectRoot();
-            const name = path.basename(root);
-            return { name, path: root };
-        }),
-        /**
-         * Get Vibeman application information
-         */
-        getVibemanInfo: publicProcedure.query(async () => {
-            return getVibemanInfo();
-        }),
-        /**
-         * 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

@@ -1,141 +0,0 @@
-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

@@ -1,238 +0,0 @@
-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'}`);
-            }
-        }),
-    };
-}