vibeman 0.0.5 → 0.0.6

package/dist/runtime/api/agent/prompt-service.test.js

@@ -1,265 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { PromptService } from './prompt-service.js';
-const TEST_DATA_DIR = path.resolve(process.cwd(), '.test-prompt-service');
-const TEST_TASKS_DIR = path.join(TEST_DATA_DIR, 'tasks');
-// Mock getVibeDir to return test directory
-vi.mock('../lib/server/project-root', () => ({
-    getVibeDir: () => TEST_DATA_DIR,
-    getProjectRoot: () => TEST_DATA_DIR,
-}));
-// Mock TaskService
-const mockTaskService = {
-    getTask: vi.fn(),
-    getAllTasks: vi.fn(),
-};
-describe('PromptService Task File Path Integration', () => {
-    let promptService;
-    beforeEach(async () => {
-        promptService = new PromptService(TEST_DATA_DIR, mockTaskService);
-        // Create test directories
-        await fs.mkdir(TEST_TASKS_DIR, { recursive: true });
-    });
-    afterEach(async () => {
-        // Clean up test data
-        try {
-            await fs.rm(TEST_DATA_DIR, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    });
-    describe('generateTaskPrompt', () => {
-        it('should include absolute path when task file exists', async () => {
-            const mockTask = {
-                id: 'TEST-TASK-001',
-                title: 'Test Task',
-                type: 'feature',
-                status: 'in-progress',
-                priority: 'high',
-                tags: ['test'],
-                content: 'Test task content',
-                created_at: '2024-09-04T12:00:00.000Z',
-                updated_at: '2024-09-04T12:00:00.000Z',
-                assignee: [],
-                comments: [],
-            };
-            // Create task file
-            const taskFilePath = path.join(TEST_TASKS_DIR, 'TEST-TASK-001.md');
-            const taskFileContent = `---
-id: TEST-TASK-001
-title: Test Task
-type: feature
-status: in-progress
-priority: high
-tags: test
----
-
-Test task content`;
-            await fs.writeFile(taskFilePath, taskFileContent, 'utf-8');
-            const prompt = await promptService.generateTaskPrompt(mockTask);
-            expect(prompt).toContain('Current task file:');
-            expect(prompt).toContain(taskFilePath);
-            expect(prompt).toContain('TEST-TASK-001');
-            expect(prompt).toContain('Test Task');
-            expect(prompt).toContain('Test task content');
-        });
-        it('should handle missing task file gracefully', async () => {
-            const mockTask = {
-                id: 'NONEXISTENT-TASK',
-                title: 'Nonexistent Task',
-                type: 'bug',
-                status: 'backlog',
-                priority: 'medium',
-                tags: [],
-                content: 'This task file does not exist',
-                created_at: '2024-09-04T12:00:00.000Z',
-                updated_at: '2024-09-04T12:00:00.000Z',
-                assignee: [],
-                comments: [],
-            };
-            const prompt = await promptService.generateTaskPrompt(mockTask);
-            expect(prompt).toContain('not accessible at expected path');
-            expect(prompt).toContain('NONEXISTENT-TASK.md');
-            expect(prompt).toContain('Nonexistent Task');
-            expect(prompt).toContain('This task file does not exist');
-        });
-        it('should handle path resolution errors', async () => {
-            // Mock generateTaskFilePath to return null (simulating path resolution error)
-            const originalGenerateTaskFilePath = promptService.generateTaskFilePath;
-            promptService.generateTaskFilePath = vi.fn().mockReturnValue(null);
-            const mockTask = {
-                id: 'ERROR-TASK',
-                title: 'Error Task',
-                type: 'chore',
-                status: 'review',
-                priority: 'low',
-                tags: ['error'],
-                content: 'Task with path resolution error',
-                created_at: '2024-09-04T12:00:00.000Z',
-                updated_at: '2024-09-04T12:00:00.000Z',
-                assignee: [],
-                comments: [],
-            };
-            const prompt = await promptService.generateTaskPrompt(mockTask);
-            expect(prompt).toContain('path could not be resolved');
-            expect(prompt).toContain('ERROR-TASK');
-            expect(prompt).toContain('Task with path resolution error');
-            // Restore original method
-            promptService.generateTaskFilePath = originalGenerateTaskFilePath;
-        });
-    });
-    describe('generateImprovementPrompt', () => {
-        it('should include task file path in project context', async () => {
-            const mockTask = {
-                id: 'IMPROVE-TASK-001',
-                title: 'Improvement Task',
-                type: 'feature',
-                status: 'backlog',
-                priority: 'medium',
-                tags: [],
-                content: 'Original content',
-                created_at: '2024-09-04T12:00:00.000Z',
-                updated_at: '2024-09-04T12:00:00.000Z',
-                assignee: [],
-                comments: [],
-            };
-            const taskData = {
-                title: 'Improved Task',
-                type: 'feature',
-                priority: 'high',
-                content: 'Improved content',
-            };
-            const productOverviewPath = path.join(TEST_DATA_DIR, 'product_overview.md');
-            const readmePath = path.join(TEST_DATA_DIR, 'README.md');
-            await fs.writeFile(productOverviewPath, 'Existing product overview content for context.', 'utf-8');
-            await fs.writeFile(readmePath, '# Workspace README\n', 'utf-8');
-            // Create task file
-            const taskFilePath = path.join(TEST_TASKS_DIR, 'IMPROVE-TASK-001.md');
-            await fs.writeFile(taskFilePath, 'Task file content', 'utf-8');
-            const prompt = await promptService.generateImprovementPrompt(mockTask, taskData);
-            expect(prompt).not.toContain('Existing product overview content for context.');
-            expect(prompt).toContain(`**Product overview file:** ${productOverviewPath}`);
-            expect(prompt).toContain('Reference this for additional product context.');
-            expect(prompt).toContain(`**Repository README:** ${readmePath}`);
-            expect(prompt).toContain('Review this if you need additional project context.');
-            expect(prompt).toContain('Current task file location:');
-            expect(prompt).toContain(taskFilePath);
-            expect(prompt).toContain('IMPROVE-TASK-001');
-        });
-        it('should include language preservation instructions in the prompt', async () => {
-            const mockTask = {
-                id: 'LANG-TEST-001',
-                title: 'Language Test Task',
-                type: 'feature',
-                status: 'backlog',
-                priority: 'medium',
-                tags: [],
-                content: 'Test content in any language',
-                created_at: '2024-09-04T12:00:00.000Z',
-                updated_at: '2024-09-04T12:00:00.000Z',
-                assignee: [],
-                comments: [],
-            };
-            const taskData = {
-                title: 'Tarea de prueba de idioma',
-                type: 'feature',
-                priority: 'high',
-                content: 'Contenido de prueba en español',
-            };
-            const prompt = await promptService.generateImprovementPrompt(mockTask, taskData);
-            // Verify the prompt contains language preservation instructions
-            expect(prompt).toContain('Detect the language of the task content');
-            expect(prompt).toContain('respond in that SAME language');
-            expect(prompt).toContain('Keep enum fields (type, priority) in English');
-        });
-    });
-    describe('generateReviewPrompt', () => {
-        it('should include task file path in additional context', async () => {
-            const mockTask = {
-                id: 'REVIEW-TASK-001',
-                title: 'Review Task',
-                type: 'bug',
-                status: 'review',
-                priority: 'high',
-                tags: [],
-                content: 'Task under review',
-                created_at: '2024-09-04T12:00:00.000Z',
-                updated_at: '2024-09-04T12:00:00.000Z',
-                assignee: [],
-                comments: [],
-            };
-            const mockWorktree = {
-                taskId: 'REVIEW-TASK-001',
-                path: '/test/worktree',
-                branchName: 'feature/review-task-001',
-            };
-            // Create task file
-            const taskFilePath = path.join(TEST_TASKS_DIR, 'REVIEW-TASK-001.md');
-            await fs.writeFile(taskFilePath, 'Review task content', 'utf-8');
-            const prompt = await promptService.generateReviewPrompt(mockTask, mockWorktree, 'Custom review context');
-            expect(prompt).toContain('Current task file:');
-            expect(prompt).toContain(taskFilePath);
-            expect(prompt).toContain('Custom review context');
-            expect(prompt).toContain('REVIEW-TASK-001');
-        });
-    });
-    describe('cross-platform path resolution', () => {
-        it('should generate valid absolute paths on different platforms', async () => {
-            const taskId = 'CROSS-PLATFORM-TEST';
-            // Test the private method through a task prompt generation
-            const mockTask = {
-                id: taskId,
-                title: 'Cross Platform Test',
-                type: 'test',
-                status: 'in-progress',
-                priority: 'medium',
-                tags: [],
-                content: 'Cross platform path test',
-                created_at: '2024-09-04T12:00:00.000Z',
-                updated_at: '2024-09-04T12:00:00.000Z',
-                assignee: [],
-                comments: [],
-            };
-            // Create task file
-            const taskFilePath = path.join(TEST_TASKS_DIR, `${taskId}.md`);
-            await fs.writeFile(taskFilePath, 'Cross platform test content', 'utf-8');
-            const prompt = await promptService.generateTaskPrompt(mockTask);
-            // Verify the path is absolute and uses correct separators
-            const pathMatch = prompt.match(/- \*\*Current task file:\*\* (.+)/);
-            expect(pathMatch).toBeTruthy();
-            if (pathMatch) {
-                const extractedPath = pathMatch[1];
-                expect(path.isAbsolute(extractedPath)).toBe(true);
-                expect(extractedPath).toContain(taskId);
-                expect(extractedPath.endsWith('.md')).toBe(true);
-            }
-        });
-    });
-    describe('error handling', () => {
-        it('should handle file system permission errors gracefully', async () => {
-            const mockTask = {
-                id: 'PERMISSION-TEST',
-                title: 'Permission Test',
-                type: 'chore',
-                status: 'backlog',
-                priority: 'low',
-                tags: [],
-                content: 'Permission test content',
-                created_at: '2024-09-04T12:00:00.000Z',
-                updated_at: '2024-09-04T12:00:00.000Z',
-                assignee: [],
-                comments: [],
-            };
-            // Mock validateTaskFile to simulate permission error
-            const originalValidateTaskFile = promptService.validateTaskFile;
-            promptService.validateTaskFile = vi.fn().mockResolvedValueOnce(false);
-            const prompt = await promptService.generateTaskPrompt(mockTask);
-            expect(prompt).toContain('not accessible at expected path');
-            expect(prompt).toContain('PERMISSION-TEST');
-            // Restore original function
-            promptService.validateTaskFile = originalValidateTaskFile;
-        });
-    });
-});

package/dist/runtime/api/agent/routing-policy.d.ts

@@ -1,171 +0,0 @@
-/**
- * AI Routing Policy Management
- * Handles provider selection per operation with fallbacks and configuration
- */
-import { z } from 'zod';
-/**
- * Operation types that support AI routing
- */
-declare const ROUTABLE_OPERATIONS: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
-export type RoutableOperation = (typeof ROUTABLE_OPERATIONS)[number];
-/**
- * Generation options for AI execution
- */
-export declare const GenerationOptionsSchema: z.ZodObject<{
-    temperature: z.ZodOptional<z.ZodNumber>;
-    maxTokens: z.ZodOptional<z.ZodNumber>;
-    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    temperature?: number | undefined;
-    maxTokens?: number | undefined;
-    tools?: string[] | undefined;
-}, {
-    temperature?: number | undefined;
-    maxTokens?: number | undefined;
-    tools?: string[] | undefined;
-}>;
-export type GenerationOptions = z.infer<typeof GenerationOptionsSchema>;
-/**
- * Per-operation routing configuration
- */
-export declare const OperationConfigSchema: z.ZodObject<{
-    provider: z.ZodString;
-    model: z.ZodOptional<z.ZodString>;
-    options: z.ZodOptional<z.ZodObject<{
-        temperature: z.ZodOptional<z.ZodNumber>;
-        maxTokens: z.ZodOptional<z.ZodNumber>;
-        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        temperature?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: string[] | undefined;
-    }, {
-        temperature?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: string[] | undefined;
-    }>>;
-    fallback: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    provider: string;
-    options?: {
-        temperature?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: string[] | undefined;
-    } | undefined;
-    model?: string | undefined;
-    fallback?: string[] | undefined;
-}, {
-    provider: string;
-    options?: {
-        temperature?: number | undefined;
-        maxTokens?: number | undefined;
-        tools?: string[] | undefined;
-    } | undefined;
-    model?: string | undefined;
-    fallback?: string[] | undefined;
-}>;
-export type OperationConfig = z.infer<typeof OperationConfigSchema>;
-/**
- * Complete routing policy schema
- */
-export declare const RoutingPolicySchema: z.ZodObject<{
-    defaultProvider: z.ZodString;
-    operations: z.ZodOptional<z.ZodRecord<z.ZodEnum<["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"]>, z.ZodObject<{
-        provider: z.ZodString;
-        model: z.ZodOptional<z.ZodString>;
-        options: z.ZodOptional<z.ZodObject<{
-            temperature: z.ZodOptional<z.ZodNumber>;
-            maxTokens: z.ZodOptional<z.ZodNumber>;
-            tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        }, "strip", z.ZodTypeAny, {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        }, {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        }>>;
-        fallback: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        provider: string;
-        options?: {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        } | undefined;
-        model?: string | undefined;
-        fallback?: string[] | undefined;
-    }, {
-        provider: string;
-        options?: {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        } | undefined;
-        model?: string | undefined;
-        fallback?: string[] | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    defaultProvider: string;
-    operations?: Partial<Record<"execute_task" | "quality_checks" | "ai_codereview" | "ai_merge" | "improve_task", {
-        provider: string;
-        options?: {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        } | undefined;
-        model?: string | undefined;
-        fallback?: string[] | undefined;
-    }>> | undefined;
-}, {
-    defaultProvider: string;
-    operations?: Partial<Record<"execute_task" | "quality_checks" | "ai_codereview" | "ai_merge" | "improve_task", {
-        provider: string;
-        options?: {
-            temperature?: number | undefined;
-            maxTokens?: number | undefined;
-            tools?: string[] | undefined;
-        } | undefined;
-        model?: string | undefined;
-        fallback?: string[] | undefined;
-    }>> | undefined;
-}>;
-export type RoutingPolicy = z.infer<typeof RoutingPolicySchema>;
-export declare const ROUTABLE_OPERATION_LIST: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
-/**
- * Resolved provider configuration for execution
- */
-export interface ResolvedProvider {
-    provider: string;
-    model?: string;
-    options?: GenerationOptions;
-    fallbacks?: string[];
-}
-/**
- * Routing Policy Manager
- * Manages AI provider routing policies stored inside settings.json
- */
-export declare class RoutingPolicyManager {
-    private policy;
-    private readonly settingsService;
-    constructor();
-    /**
-     * Get current effective policy (lazy loads from settings)
-     */
-    getPolicy(): Promise<RoutingPolicy>;
-    /**
-     * Update routing policy and persist via settings service
-     */
-    updatePolicy(updates: Partial<RoutingPolicy>): Promise<void>;
-    /**
-     * Resolve provider for a specific operation
-     */
-    getEffectivePolicy(): Promise<RoutingPolicy>;
-    resolveProviderForOperation(operation: RoutableOperation, overrides?: Partial<ResolvedProvider>): Promise<ResolvedProvider>;
-    setDefaultProvider(provider: string): Promise<void>;
-    setOperationConfig(operation: RoutableOperation, config: OperationConfig): Promise<void>;
-    validatePolicy(policy: RoutingPolicy, availableProviders: Set<string>): string[];
-    private buildPolicyFromSettings;
-}
-export {};

package/dist/runtime/api/agent/routing-policy.js

@@ -1,196 +0,0 @@
-/**
- * AI Routing Policy Management
- * Handles provider selection per operation with fallbacks and configuration
- */
-import { z } from 'zod';
-import { log } from '../lib/logger.js';
-import { getSettingsService } from '../settings-service.js';
-/**
- * Operation types that support AI routing
- */
-const ROUTABLE_OPERATIONS = [
-    'execute_task',
-    'quality_checks',
-    'ai_codereview',
-    'ai_merge',
-    'improve_task',
-];
-/**
- * Generation options for AI execution
- */
-export const GenerationOptionsSchema = z.object({
-    temperature: z.number().min(0).max(2).optional(),
-    maxTokens: z.number().positive().optional(),
-    tools: z.array(z.string()).optional(),
-});
-/**
- * Per-operation routing configuration
- */
-export const OperationConfigSchema = z.object({
-    provider: z.string(),
-    model: z.string().optional(),
-    options: GenerationOptionsSchema.optional(),
-    fallback: z.array(z.string()).optional(),
-});
-/**
- * Complete routing policy schema
- */
-export const RoutingPolicySchema = z.object({
-    defaultProvider: z.string(),
-    operations: z.record(z.enum(ROUTABLE_OPERATIONS), OperationConfigSchema).optional(),
-});
-export const ROUTABLE_OPERATION_LIST = ROUTABLE_OPERATIONS;
-/**
- * Routing Policy Manager
- * Manages AI provider routing policies stored inside settings.json
- */
-export class RoutingPolicyManager {
-    constructor() {
-        this.policy = null;
-        this.settingsService = getSettingsService();
-        // Invalidate cached policy when settings change
-        this.settingsService.on('settingsUpdated', () => {
-            this.policy = null;
-        });
-    }
-    /**
-     * Get current effective policy (lazy loads from settings)
-     */
-    async getPolicy() {
-        if (!this.policy) {
-            this.policy = this.buildPolicyFromSettings();
-        }
-        return this.policy;
-    }
-    /**
-     * Update routing policy and persist via settings service
-     */
-    async updatePolicy(updates) {
-        const currentPolicy = await this.getPolicy();
-        const mergedOperations = {
-            ...(currentPolicy.operations ?? {}),
-            ...(updates.operations ?? {}),
-        };
-        const operationsKeys = Object.keys(mergedOperations);
-        const nextPolicy = {
-            defaultProvider: updates.defaultProvider ?? currentPolicy.defaultProvider,
-            ...(operationsKeys.length > 0 ? { operations: mergedOperations } : {}),
-        };
-        const validated = RoutingPolicySchema.parse(nextPolicy);
-        await this.settingsService.updateSettings([
-            { path: ['agents', 'routingPolicy'], value: validated },
-        ]);
-        this.policy = validated;
-        log.info('Updated AI routing policy', { policy: validated }, 'routing-policy');
-    }
-    /**
-     * Resolve provider for a specific operation
-     */
-    async getEffectivePolicy() {
-        const base = await this.getPolicy();
-        const operations = {
-            ...base.operations,
-        };
-        for (const op of ROUTABLE_OPERATIONS) {
-            if (!operations[op]) {
-                const resolved = await this.resolveProviderForOperation(op);
-                operations[op] = {
-                    provider: resolved.provider,
-                    ...(resolved.model ? { model: resolved.model } : {}),
-                    ...(resolved.options ? { options: resolved.options } : {}),
-                    ...(resolved.fallbacks && resolved.fallbacks.length
-                        ? { fallback: resolved.fallbacks }
-                        : {}),
-                };
-            }
-        }
-        return {
-            defaultProvider: base.defaultProvider,
-            operations,
-        };
-    }
-    async resolveProviderForOperation(operation, overrides) {
-        const policy = await this.getPolicy();
-        const operationConfig = policy.operations?.[operation];
-        // Pull provider/model defaults from settings per operation
-        const settings = this.settingsService.getSettings();
-        const coding = settings.agents?.codingAgent;
-        const judge = settings.agents?.judgeAgent;
-        const settingsProviderModel = (() => {
-            switch (operation) {
-                case 'ai_codereview':
-                    return { provider: judge?.provider, model: judge?.model };
-                case 'execute_task':
-                case 'quality_checks':
-                case 'ai_merge':
-                case 'improve_task':
-                default:
-                    return { provider: coding?.provider, model: coding?.model };
-            }
-        })();
-        // Start with operation-specific config or fall back to settings, then default policy
-        const baseProvider = operationConfig?.provider || settingsProviderModel.provider || policy.defaultProvider;
-        const baseModel = operationConfig?.model
-            ? operationConfig.model
-            : operationConfig?.provider
-                ? undefined
-                : settingsProviderModel.model;
-        const baseOptions = operationConfig?.options;
-        const baseFallbacks = operationConfig?.fallback || [];
-        // Apply overrides
-        const overrideProviderOnly = overrides?.provider && overrides.model === undefined;
-        const resolved = {
-            provider: overrides?.provider || baseProvider,
-            model: overrideProviderOnly ? undefined : overrides?.model || baseModel,
-            options: overrides?.options || baseOptions,
-            fallbacks: overrides?.fallbacks || baseFallbacks,
-        };
-        log.debug(`Resolved provider for ${operation}`, { operation, resolved }, 'routing-policy');
-        return resolved;
-    }
-    async setDefaultProvider(provider) {
-        await this.updatePolicy({ defaultProvider: provider });
-    }
-    async setOperationConfig(operation, config) {
-        const currentPolicy = await this.getPolicy();
-        const operations = {
-            ...(currentPolicy.operations ?? {}),
-            [operation]: config,
-        };
-        await this.updatePolicy({ operations });
-    }
-    validatePolicy(policy, availableProviders) {
-        const errors = [];
-        if (!availableProviders.has(policy.defaultProvider)) {
-            errors.push(`Default provider '${policy.defaultProvider}' is not available`);
-        }
-        if (policy.operations) {
-            for (const [operation, config] of Object.entries(policy.operations)) {
-                if (!availableProviders.has(config.provider)) {
-                    errors.push(`Provider '${config.provider}' for operation '${operation}' is not available`);
-                }
-                if (config.fallback) {
-                    for (const fallbackProvider of config.fallback) {
-                        if (!availableProviders.has(fallbackProvider)) {
-                            errors.push(`Fallback provider '${fallbackProvider}' for operation '${operation}' is not available`);
-                        }
-                    }
-                }
-            }
-        }
-        return errors;
-    }
-    buildPolicyFromSettings() {
-        const settings = this.settingsService.getSettings();
-        const settingsPolicy = settings.agents?.routingPolicy;
-        const defaultProvider = settingsPolicy?.defaultProvider || settings.agents.defaultProvider || 'claude-code';
-        const operations = settingsPolicy?.operations
-            ? { ...settingsPolicy.operations }
-            : undefined;
-        const policy = {
-            defaultProvider,
-            ...(operations ? { operations } : {}),
-        };
-        return RoutingPolicySchema.parse(policy);
-    }
-}

package/dist/runtime/api/agent/routing-policy.test.d.ts

@@ -1 +0,0 @@
-export {};