vibeman 0.0.3 → 0.0.6

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

@@ -1,94 +0,0 @@
-import { z } from 'zod';
-import { on, EventEmitter } from 'events';
-import { publicProcedure } from '../trpc.js';
-import { ExecutionIdSchema, TaskIdSchema } from '../router-helpers.js';
-import { makeAssertTaskActive } from '../router-helpers.js';
-import { log } from '../../lib/logger.js';
-export function buildExecutionRoutes({ taskService, vibingOrchestrator }) {
-    const assertTaskActive = makeAssertTaskActive(taskService);
-    return {
-        executeTask: publicProcedure.input(TaskIdSchema).mutation(async ({ input }) => {
-            assertTaskActive(input.taskId);
-            const { executionId } = await vibingOrchestrator.executeTask(input.taskId);
-            return { executionId };
-        }),
-        stopTaskExecution: publicProcedure.input(ExecutionIdSchema).mutation(async ({ input }) => {
-            await vibingOrchestrator.stopExecution(input.executionId);
-            return { success: true };
-        }),
-        getTaskExecutionStatus: publicProcedure.input(ExecutionIdSchema).query(async ({ input }) => {
-            return vibingOrchestrator.getExecutionStatus(input.executionId);
-        }),
-        getTaskExecutionLogs: publicProcedure.input(ExecutionIdSchema).query(async ({ input }) => {
-            try {
-                const persistedLogs = await vibingOrchestrator.getPersistedExecutionLogs(input.executionId);
-                return { logs: persistedLogs.logs };
-            }
-            catch (error) {
-                log.error('Failed to get task execution logs', error);
-                const logs = vibingOrchestrator.getExecutionLogs(input.executionId);
-                const logEntries = logs.map((message, index) => ({
-                    timestamp: new Date().toISOString(),
-                    level: 'info',
-                    message,
-                    data: { index },
-                }));
-                return { logs: logEntries };
-            }
-        }),
-        getTaskExecutions: publicProcedure.input(TaskIdSchema).query(async ({ input }) => {
-            return vibingOrchestrator.getTaskExecutions(input.taskId);
-        }),
-        getTaskExecutionStats: publicProcedure.query(async () => {
-            return vibingOrchestrator.getExecutionStats();
-        }),
-        improveTask: publicProcedure
-            .input(z.object({
-            taskId: z.string(),
-            title: z.string(),
-            type: z.enum(['feature', 'bug', 'chore', 'refactor', 'test', 'doc']),
-            priority: z.enum(['low', 'medium', 'high']),
-            content: z.string(),
-            executionId: z.string().optional(),
-        }))
-            .mutation(async ({ input }) => {
-            assertTaskActive(input.taskId);
-            const improvement = await vibingOrchestrator.improveTaskContent(input.taskId, {
-                title: input.title,
-                type: input.type,
-                priority: input.priority,
-                content: input.content,
-            }, { executionId: input.executionId });
-            return improvement;
-        }),
-        onExecutionUpdate: publicProcedure
-            .input(z.object({ executionId: z.string() }))
-            .subscription(async function* (opts) {
-            const input = opts.input;
-            // Emit initial status if exists
-            const initial = vibingOrchestrator.getExecutionStatus(input.executionId);
-            if (initial) {
-                yield {
-                    executionId: initial.id,
-                    status: initial.status,
-                    logs: initial.logs,
-                    error: initial.error,
-                };
-            }
-            const proxy = new EventEmitter();
-            const handleUpdate = (update) => {
-                if (update.executionId === input.executionId)
-                    proxy.emit('data', update);
-            };
-            vibingOrchestrator.on('executionUpdated', handleUpdate);
-            try {
-                for await (const [payload] of on(proxy, 'data', { signal: opts.signal })) {
-                    yield payload;
-                }
-            }
-            finally {
-                vibingOrchestrator.off('executionUpdated', handleUpdate);
-            }
-        }),
-    };
-}

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

@@ -1,45 +0,0 @@
-import type { TaskService } from '../../tasks/task-service.js';
-import type { GitService } from '../../vcs/git-service.js';
-export declare function buildGitRoutes(taskService: TaskService, gitService: GitService): {
-    readonly getGitStatus: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: {
-            current: string;
-            staged: string[];
-            modified: string[];
-            untracked: string[];
-            ahead: number;
-            behind: number;
-        };
-        meta: object;
-    }>;
-    readonly createBranch: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            taskId: string;
-            baseBranch?: string | undefined;
-        };
-        output: import("../../vcs/git-service.js").BranchInfo;
-        meta: object;
-    }>;
-    readonly commitChanges: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            taskId: string;
-            message?: string | undefined;
-            files?: string[] | undefined;
-        };
-        output: import("../../vcs/git-service.js").CommitInfo;
-        meta: object;
-    }>;
-    readonly getCommitHistory: import("@trpc/server").TRPCQueryProcedure<{
-        input: {
-            maxCount?: number | undefined;
-        };
-        output: import("../../vcs/git-service.js").CommitInfo[];
-        meta: object;
-    }>;
-    readonly hasUncommittedChanges: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: boolean;
-        meta: object;
-    }>;
-};

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

@@ -1,35 +0,0 @@
-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/provider-config.d.ts

@@ -1,165 +0,0 @@
-/**
- * Provider Configuration Router
- * Handles provider detection and local configuration management
- */
-/**
- * Provider Configuration Router
- */
-export declare function buildProviderConfigRoutes(): {
-    /**
-     * Detect all providers with current status
-     */
-    detectAllProviders: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: Record<string, import("../../lib/provider-detection.js").DetectionResult>;
-        meta: object;
-    }>;
-    /**
-     * Detect specific provider
-     */
-    detectProvider: import("@trpc/server").TRPCQueryProcedure<{
-        input: {
-            provider: string;
-        };
-        output: import("../../lib/provider-detection.js").DetectionResult;
-        meta: object;
-    }>;
-    /**
-     * Set explicit provider path
-     */
-    setProviderPath: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            path: string;
-            provider: string;
-        };
-        output: {
-            success: boolean;
-            result: import("../../lib/provider-detection.js").DetectionResult;
-        };
-        meta: object;
-    }>;
-    /**
-     * Clear provider path (reset to auto-detection)
-     */
-    clearProviderPath: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            provider: string;
-        };
-        output: {
-            success: boolean;
-        };
-        meta: object;
-    }>;
-    /**
-     * Get local configuration info
-     */
-    getLocalConfigInfo: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: {
-            providers: {
-                'claude-code'?: {
-                    binPath?: string | undefined;
-                    detectedPath?: string | undefined;
-                    lastDetected?: string | undefined;
-                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
-                } | undefined;
-                codex?: {
-                    binPath?: string | undefined;
-                    detectedPath?: string | undefined;
-                    lastDetected?: string | undefined;
-                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
-                } | undefined;
-            };
-            path: string;
-            exists: boolean;
-            size?: number;
-        };
-        meta: object;
-    }>;
-    /**
-     * Clear validation cache (force re-detection)
-     */
-    clearValidationCache: import("@trpc/server").TRPCMutationProcedure<{
-        input: void;
-        output: {
-            success: boolean;
-        };
-        meta: object;
-    }>;
-    /**
-     * Get provider detection diagnostics
-     */
-    getProviderDiagnostics: import("@trpc/server").TRPCQueryProcedure<{
-        input: void;
-        output: {
-            localConfigPath: string;
-            localConfigExists: boolean;
-            providers: {
-                provider: string;
-                detection: import("../../lib/provider-detection.js").DetectionResult;
-                localConfig: {
-                    binPath?: string | undefined;
-                    detectedPath?: string | undefined;
-                    lastDetected?: string | undefined;
-                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
-                } | {
-                    binPath?: string | undefined;
-                    detectedPath?: string | undefined;
-                    lastDetected?: string | undefined;
-                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
-                } | undefined;
-                cached: {
-                    available: boolean;
-                    error: string | undefined;
-                    version: string | undefined;
-                    checkedAt: string;
-                    isFresh: boolean;
-                } | null;
-            }[];
-        };
-        meta: object;
-    }>;
-};
-/**
- * Test-friendly plain handlers
- */
-export declare function buildProviderConfigRouteHandlers(): {
-    readonly detectAllProviders: () => Promise<Record<string, import("../../lib/provider-detection.js").DetectionResult>>;
-    readonly detectProvider: (input: {
-        provider: string;
-    }) => Promise<import("../../lib/provider-detection.js").DetectionResult>;
-    readonly setProviderPath: (input: {
-        provider: string;
-        path: string;
-    }) => Promise<{
-        success: true;
-        result: import("../../lib/provider-detection.js").DetectionResult;
-    }>;
-    readonly clearProviderPath: (input: {
-        provider: string;
-    }) => Promise<{
-        success: true;
-    }>;
-    readonly getLocalConfigInfo: () => Promise<{
-        providers: {
-            'claude-code'?: {
-                binPath?: string | undefined;
-                detectedPath?: string | undefined;
-                lastDetected?: string | undefined;
-                detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
-            } | undefined;
-            codex?: {
-                binPath?: string | undefined;
-                detectedPath?: string | undefined;
-                lastDetected?: string | undefined;
-                detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
-            } | undefined;
-        };
-        path: string;
-        exists: boolean;
-        size?: number;
-    }>;
-    readonly clearValidationCache: () => Promise<{
-        success: true;
-    }>;
-};

package/dist/runtime/api/api/routers/provider-config.js

@@ -1,252 +0,0 @@
-/**
- * Provider Configuration Router
- * Handles provider detection and local configuration management
- */
-import { z } from 'zod';
-import { publicProcedure } from '../trpc.js';
-import { getProviderDetectionService } from '../../lib/provider-detection.js';
-import { getLocalConfigService } from '../../lib/local-config.js';
-import { log } from '../../lib/logger.js';
-/**
- * Input schemas for API endpoints
- */
-const DetectProviderInputSchema = z.object({
-    provider: z.string(),
-});
-const SetProviderPathInputSchema = z.object({
-    provider: z.string(),
-    path: z.string().trim().min(1, 'Path is required'),
-});
-const ClearProviderPathInputSchema = z.object({
-    provider: z.string(),
-});
-/**
- * Provider Configuration Router
- */
-export function buildProviderConfigRoutes() {
-    return {
-        /**
-         * Detect all providers with current status
-         */
-        detectAllProviders: publicProcedure.query(async () => {
-            try {
-                const detectionService = getProviderDetectionService();
-                const results = await detectionService.detectAllProviders();
-                log.debug('Detected all providers', { results }, 'provider-config');
-                return results;
-            }
-            catch (error) {
-                const msg = `Failed to detect providers: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'provider-config');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Detect specific provider
-         */
-        detectProvider: publicProcedure.input(DetectProviderInputSchema).query(async ({ input }) => {
-            try {
-                const detectionService = getProviderDetectionService();
-                const result = await detectionService.detectProvider(input.provider);
-                log.debug('Detected provider', { provider: input.provider, result }, 'provider-config');
-                return result;
-            }
-            catch (error) {
-                const msg = `Failed to detect provider ${input.provider}: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'provider-config');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Set explicit provider path
-         */
-        setProviderPath: publicProcedure
-            .input(SetProviderPathInputSchema)
-            .mutation(async ({ input }) => {
-            try {
-                const detectionService = getProviderDetectionService();
-                const result = await detectionService.setProviderPath(input.provider, input.path);
-                if (!result.found) {
-                    throw new Error(result.error || 'Invalid provider path');
-                }
-                log.info('Set provider path', { provider: input.provider, path: input.path }, 'provider-config');
-                return { success: true, result };
-            }
-            catch (error) {
-                const msg = `Failed to set provider path: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'provider-config');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Clear provider path (reset to auto-detection)
-         */
-        clearProviderPath: publicProcedure
-            .input(ClearProviderPathInputSchema)
-            .mutation(async ({ input }) => {
-            try {
-                const detectionService = getProviderDetectionService();
-                await detectionService.clearProviderPath(input.provider);
-                log.info('Cleared provider path', { provider: input.provider }, 'provider-config');
-                return { success: true };
-            }
-            catch (error) {
-                const msg = `Failed to clear provider path: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'provider-config');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Get local configuration info
-         */
-        getLocalConfigInfo: publicProcedure.query(async () => {
-            try {
-                const localConfig = getLocalConfigService();
-                await localConfig.initialize();
-                const info = await localConfig.getConfigInfo();
-                const config = localConfig.getConfig();
-                return {
-                    ...info,
-                    providers: config.providers || {},
-                };
-            }
-            catch (error) {
-                const msg = `Failed to get local config info: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'provider-config');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Clear validation cache (force re-detection)
-         */
-        clearValidationCache: publicProcedure.mutation(async () => {
-            try {
-                const localConfig = getLocalConfigService();
-                await localConfig.initialize();
-                await localConfig.clearValidationCache();
-                log.info('Cleared validation cache', undefined, 'provider-config');
-                return { success: true };
-            }
-            catch (error) {
-                const msg = `Failed to clear validation cache: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'provider-config');
-                throw new Error(msg);
-            }
-        }),
-        /**
-         * Get provider detection diagnostics
-         */
-        getProviderDiagnostics: publicProcedure.query(async () => {
-            try {
-                const detectionService = getProviderDetectionService();
-                const localConfig = getLocalConfigService();
-                await localConfig.initialize();
-                const detectionResults = await detectionService.detectAllProviders();
-                const localConfigInfo = await localConfig.getConfigInfo();
-                const providerConfigs = localConfig.getConfig().providers || {};
-                const diagnostics = Object.entries(detectionResults).map(([provider, result]) => {
-                    const config = providerConfigs[provider];
-                    const cached = localConfig.getCachedValidationResult(provider);
-                    return {
-                        provider,
-                        detection: result,
-                        localConfig: config,
-                        cached: cached
-                            ? {
-                                available: cached.available,
-                                error: cached.error,
-                                version: cached.version,
-                                checkedAt: cached.checkedAt,
-                                isFresh: localConfig.isCachedValidationFresh(provider),
-                            }
-                            : null,
-                    };
-                });
-                return {
-                    localConfigPath: localConfigInfo.path,
-                    localConfigExists: localConfigInfo.exists,
-                    providers: diagnostics,
-                };
-            }
-            catch (error) {
-                const msg = `Failed to get provider diagnostics: ${error instanceof Error ? error.message : String(error)}`;
-                log.error(msg, error, 'provider-config');
-                throw new Error(msg);
-            }
-        }),
-    };
-}
-/**
- * Test-friendly plain handlers
- */
-export function buildProviderConfigRouteHandlers() {
-    return {
-        async detectAllProviders() {
-            try {
-                const detectionService = getProviderDetectionService();
-                return await detectionService.detectAllProviders();
-            }
-            catch (error) {
-                throw new Error(`Failed to detect providers: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async detectProvider(input) {
-            try {
-                const detectionService = getProviderDetectionService();
-                return await detectionService.detectProvider(input.provider);
-            }
-            catch (error) {
-                throw new Error(`Failed to detect provider ${input.provider}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async setProviderPath(input) {
-            try {
-                const detectionService = getProviderDetectionService();
-                const result = await detectionService.setProviderPath(input.provider, input.path);
-                if (!result.found) {
-                    throw new Error(result.error || 'Invalid provider path');
-                }
-                return { success: true, result };
-            }
-            catch (error) {
-                throw new Error(`Failed to set provider path: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async clearProviderPath(input) {
-            try {
-                const detectionService = getProviderDetectionService();
-                await detectionService.clearProviderPath(input.provider);
-                return { success: true };
-            }
-            catch (error) {
-                throw new Error(`Failed to clear provider path: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async getLocalConfigInfo() {
-            try {
-                const localConfig = getLocalConfigService();
-                await localConfig.initialize();
-                const info = await localConfig.getConfigInfo();
-                const config = localConfig.getConfig();
-                return {
-                    ...info,
-                    providers: config.providers || {},
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to get local config info: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-        async clearValidationCache() {
-            try {
-                const localConfig = getLocalConfigService();
-                await localConfig.initialize();
-                await localConfig.clearValidationCache();
-                return { success: true };
-            }
-            catch (error) {
-                throw new Error(`Failed to clear validation cache: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        },
-    };
-}