vibeman 0.0.5 → 0.0.7

package/dist/runtime/api/settings-service.js

@@ -1,678 +0,0 @@
-/**
- * Settings Service - Centralized configuration management
- *
- * Provides persistent storage and validation for application settings
- * with atomic write operations and schema validation using Zod.
- */
-import { EventEmitter } from 'events';
-import fs from 'fs/promises';
-import path from 'path';
-import { z } from 'zod';
-import { log } from './lib/logger.js';
-import { getProjectRoot } from './lib/server/project-root.js';
-// Zod schema for validation
-const CLAUDE_ALLOWED_MODELS = [
-    'claude-sonnet-4-20250514',
-    'claude-opus-4-1-20250805',
-    'claude-3-5-haiku-20241022',
-];
-const CODEX_BASE_MODELS = [
-    'gpt-5.1-codex-max',
-    'gpt-5.1-codex',
-    'gpt-5.1-codex-mini',
-    'gpt-5.2',
-    'gpt-5.1',
-];
-const CODEX_REASONING_SUFFIXES = ['low', 'medium', 'high', 'extra-high'];
-const CODEX_ALLOWED_MODELS = [
-    ...CODEX_BASE_MODELS,
-    ...CODEX_BASE_MODELS.flatMap((base) => CODEX_REASONING_SUFFIXES.map((suffix) => `${base}-${suffix}`)),
-];
-const GEMINI_ALLOWED_MODELS = [
-    'gemini-3-pro-preview',
-    'gemini-3-flash-preview',
-    'gemini-2.5-pro',
-    'gemini-2.5-flash',
-    'gemini-2.5-flash-lite',
-];
-const AUTO_ALLOWED_MODELS = ['auto'];
-const MODEL_ENUM = [
-    ...CLAUDE_ALLOWED_MODELS,
-    ...CODEX_ALLOWED_MODELS,
-    ...GEMINI_ALLOWED_MODELS,
-    ...AUTO_ALLOWED_MODELS,
-];
-const ROUTABLE_OPERATIONS = [
-    'execute_task',
-    'quality_checks',
-    'ai_codereview',
-    'ai_merge',
-    'improve_task',
-];
-const RoutingOperationSchema = z.object({
-    provider: z.string(),
-    model: z.string().optional(),
-    options: z
-        .object({
-        temperature: z.number().min(0).max(2).optional(),
-        maxTokens: z.number().positive().optional(),
-        tools: z.array(z.string()).optional(),
-    })
-        .optional(),
-    fallback: z.array(z.string()).optional(),
-});
-const RoutingPolicySettingsSchema = z
-    .object({
-    defaultProvider: z.enum(['claude-code', 'codex', 'gemini', 'amp']).optional(),
-    operations: z.record(z.enum(ROUTABLE_OPERATIONS), RoutingOperationSchema).optional(),
-})
-    .optional();
-const VibemanSettingsSchema = z.object({
-    agents: z.object({
-        defaultProvider: z.enum(['claude-code', 'codex', 'gemini', 'amp']),
-        codingAgent: z.object({
-            provider: z.enum(['claude-code', 'codex', 'gemini', 'amp']),
-            model: z.enum(MODEL_ENUM),
-            maxTokens: z.number().min(256).max(10000000000000).optional(),
-        }),
-        judgeAgent: z.object({
-            provider: z.enum(['claude-code', 'codex', 'gemini', 'amp']),
-            model: z.enum(MODEL_ENUM),
-            maxTokens: z.number().min(256).max(10000000000000).optional(),
-            reviewThresholdScore: z.number().min(0).max(100),
-        }),
-        defaultPrompts: z.object({
-            systemPrompt: z.string().min(10),
-            taskPrompt: z.string().min(10),
-        }),
-        // Note: Provider binary paths are now stored in local config (.vibeman/.local/)
-        // This field is kept for backwards compatibility but deprecated
-        providers: z
-            .object({
-            claudeCode: z.object({ binPath: z.string().min(1).optional() }).optional(),
-            codex: z.object({ binPath: z.string().min(1).optional() }).optional(),
-            gemini: z.object({ binPath: z.string().min(1).optional() }).optional(),
-            amp: z.object({ binPath: z.string().min(1).optional() }).optional(),
-        })
-            .optional(),
-        routingPolicy: RoutingPolicySettingsSchema,
-    }),
-    defaultWorkflow: z.object({
-        autoQualityChecks: z.boolean(),
-        requireHumanApproval: z.boolean(),
-        aiCodeReview: z.boolean(),
-        maxImplementationAttempts: z.number().min(1).max(10),
-        autoCommit: z.boolean(),
-    }),
-    quality: z
-        .object({
-        checks: z.array(z.object({
-            name: z.string().min(1),
-            command: z.string().min(1),
-            args: z.array(z.string()).optional(),
-            timeout: z
-                .number()
-                .min(1000)
-                .max(10 * 60 * 1000)
-                .optional(),
-            enabled: z.boolean().optional(),
-        })),
-    })
-        .optional(),
-    development: z.object({
-        vibeDir: z.string().min(1).optional(),
-        git: z.object({
-            defaultBranch: z.string().min(1),
-            worktreePath: z.string().min(1).optional(),
-        }),
-        editor: z
-            .object({
-            type: z.enum(['vscode', 'cursor', 'vim', 'custom']).optional(),
-            command: z.string().min(1).optional(),
-            args: z.array(z.string()).optional(),
-            name: z.string().min(1).optional(),
-            openFileCommand: z.array(z.string()).optional(),
-            openFolderCommand: z.array(z.string()).optional(),
-        })
-            .optional(),
-        terminal: z
-            .object({
-            type: z.enum(['system', 'iterm2', 'warp', 'custom']).optional(),
-            command: z.string().min(1).optional(),
-            args: z.array(z.string()).optional(),
-            name: z.string().min(1).optional(),
-            openCommand: z.array(z.string()).optional(),
-        })
-            .optional(),
-    }),
-    server: z.object({
-        port: z.number().min(3000).max(65535),
-        host: z.string().min(1),
-        autoOpenBrowser: z.boolean(),
-    }),
-});
-// Default settings
-const DEFAULT_SETTINGS = {
-    agents: {
-        defaultProvider: 'claude-code',
-        codingAgent: {
-            provider: 'claude-code',
-            model: 'claude-sonnet-4-20250514',
-        },
-        judgeAgent: {
-            provider: 'claude-code',
-            model: 'claude-sonnet-4-20250514',
-            reviewThresholdScore: 70,
-        },
-        defaultPrompts: {
-            systemPrompt: 'You are a senior software engineer assistant. Follow best practices and write clean, maintainable code.',
-            taskPrompt: 'Please implement the following task with attention to quality and testing.',
-        },
-        providers: {},
-        routingPolicy: {
-            defaultProvider: 'claude-code',
-            operations: {},
-        },
-    },
-    defaultWorkflow: {
-        autoQualityChecks: true,
-        requireHumanApproval: true,
-        aiCodeReview: true,
-        maxImplementationAttempts: 3,
-        autoCommit: false,
-    },
-    quality: {
-        checks: [],
-    },
-    development: {
-        git: {
-            defaultBranch: 'main',
-        },
-        editor: {
-            type: 'vscode',
-            command: 'code',
-            args: [],
-            name: 'Visual Studio Code',
-            openFileCommand: ['code', '${file}'],
-            openFolderCommand: ['code', '${folder}'],
-        },
-        terminal: {
-            type: 'system',
-            command: process.platform === 'darwin'
-                ? 'open'
-                : process.platform === 'win32'
-                    ? 'cmd'
-                    : 'gnome-terminal',
-            args: process.platform === 'darwin' ? ['-a', 'Terminal'] : [],
-            name: process.platform === 'darwin'
-                ? 'Terminal'
-                : process.platform === 'win32'
-                    ? 'Command Prompt'
-                    : 'Terminal',
-            openCommand: process.platform === 'darwin'
-                ? ['open', '-a', 'Terminal', '${cwd}']
-                : process.platform === 'win32'
-                    ? ['cmd', '/c', 'start', 'cmd', '/k', 'cd', '/d', '${cwd}']
-                    : ['gnome-terminal', '--working-directory=${cwd}'],
-        },
-    },
-    server: {
-        port: 6969,
-        host: 'localhost',
-        autoOpenBrowser: true,
-    },
-};
-export class SettingsService extends EventEmitter {
-    constructor(config = {}) {
-        super();
-        this.settings = { ...DEFAULT_SETTINGS };
-        this.initialized = false;
-        const settingsDir = config.settingsDir ?? '.vibeman/.local';
-        const settingsFileName = config.settingsFileName ?? 'settings.json';
-        // Resolve settings path relative to the repo project root (not package CWD)
-        const projectRoot = getProjectRoot();
-        this.settingsPath = path.join(projectRoot, settingsDir, settingsFileName);
-    }
-    /**
-     * Initialize the settings service
-     */
-    async initialize() {
-        if (this.initialized)
-            return;
-        try {
-            await this.ensureSettingsDirectory();
-            await this.loadSettings();
-            this.initialized = true;
-            log.info('Settings service initialized', { settingsPath: this.settingsPath }, 'settings-service');
-        }
-        catch (error) {
-            log.error('Failed to initialize settings service', error, 'settings-service');
-            throw error;
-        }
-    }
-    /**
-     * Get all current settings
-     */
-    getSettings() {
-        return { ...this.settings };
-    }
-    /**
-     * Get a specific setting by path
-     */
-    getSetting(path) {
-        let current = this.settings;
-        for (const key of path) {
-            if (current && typeof current === 'object' && key in current) {
-                current = current[key];
-            }
-            else {
-                return undefined;
-            }
-        }
-        return current;
-    }
-    /**
-     * Update settings with validation
-     */
-    async updateSettings(updates) {
-        // Create a copy to test updates
-        const testSettings = JSON.parse(JSON.stringify(this.settings));
-        const errors = [];
-        // Apply all updates to test copy
-        for (const update of updates) {
-            try {
-                this.applySingleUpdate(testSettings, update.path, update.value);
-            }
-            catch (error) {
-                errors.push({
-                    path: update.path,
-                    message: error instanceof Error ? error.message : 'Invalid update',
-                });
-            }
-        }
-        // Validate the entire updated settings object
-        try {
-            const validated = VibemanSettingsSchema.parse(testSettings);
-            if (errors.length === 0) {
-                // Apply updates to actual settings
-                this.settings = validated;
-                await this.saveSettings();
-                // Emit change events
-                for (const update of updates) {
-                    this.emit('settingChanged', {
-                        path: update.path,
-                        oldValue: this.getSetting(update.path),
-                        newValue: update.value,
-                    });
-                }
-                this.emit('settingsUpdated', this.settings);
-                return { success: true, errors: [] };
-            }
-        }
-        catch (validationError) {
-            if (validationError instanceof z.ZodError) {
-                for (const issue of validationError.issues) {
-                    errors.push({
-                        path: issue.path.map(String),
-                        message: issue.message,
-                        expected: 'Valid value according to schema',
-                    });
-                }
-            }
-            else {
-                errors.push({
-                    path: [],
-                    message: validationError instanceof Error ? validationError.message : 'Validation failed',
-                });
-            }
-        }
-        return { success: false, errors };
-    }
-    /**
-     * Reset settings to defaults
-     */
-    async resetToDefaults() {
-        this.settings = { ...DEFAULT_SETTINGS };
-        await this.saveSettings();
-        this.emit('settingsReset', this.settings);
-        log.info('Settings reset to defaults', undefined, 'settings-service');
-    }
-    /**
-     * Validate settings schema
-     */
-    validateSettings(settings) {
-        try {
-            VibemanSettingsSchema.parse(settings);
-            return { valid: true, errors: [] };
-        }
-        catch (error) {
-            const errors = [];
-            if (error instanceof z.ZodError) {
-                for (const issue of error.issues) {
-                    errors.push({
-                        path: issue.path.map(String),
-                        message: issue.message,
-                        expected: 'Valid value according to schema',
-                    });
-                }
-            }
-            else {
-                errors.push({
-                    path: [],
-                    message: error instanceof Error ? error.message : 'Validation failed',
-                });
-            }
-            return { valid: false, errors };
-        }
-    }
-    /**
-     * Get settings file information
-     */
-    async getSettingsInfo() {
-        return {
-            path: this.settingsPath,
-            exists: await this.fileExists(this.settingsPath),
-        };
-    }
-    /**
-     * Get predefined editor configurations
-     */
-    getEditorPresets() {
-        return {
-            vscode: {
-                type: 'vscode',
-                command: 'code',
-                name: 'Visual Studio Code',
-                openFileCommand: ['code', '${file}'],
-                openFolderCommand: ['code', '${folder}'],
-            },
-            cursor: {
-                type: 'cursor',
-                command: 'cursor',
-                name: 'Cursor',
-                openFileCommand: ['cursor', '${file}'],
-                openFolderCommand: ['cursor', '${folder}'],
-            },
-            vim: {
-                type: 'vim',
-                command: 'vim',
-                name: 'Vim',
-                openFileCommand: ['vim', '${file}'],
-                openFolderCommand: ['vim', '${folder}'],
-            },
-        };
-    }
-    /**
-     * Get predefined terminal configurations
-     */
-    getTerminalPresets() {
-        const platform = process.platform;
-        return {
-            system: {
-                type: 'system',
-                command: platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'gnome-terminal',
-                args: platform === 'darwin' ? ['-a', 'Terminal'] : [],
-                name: platform === 'darwin' ? 'Terminal' : platform === 'win32' ? 'Command Prompt' : 'Terminal',
-                openCommand: platform === 'darwin'
-                    ? ['open', '-a', 'Terminal', '${cwd}']
-                    : platform === 'win32'
-                        ? ['cmd', '/c', 'start', 'cmd', '/k', 'cd', '/d', '${cwd}']
-                        : ['gnome-terminal', '--working-directory=${cwd}'],
-            },
-            iterm2: {
-                type: 'iterm2',
-                command: 'open',
-                args: ['-a', 'iTerm'],
-                name: 'iTerm2',
-                openCommand: ['open', '-a', 'iTerm', '${cwd}'],
-            },
-            warp: {
-                type: 'warp',
-                command: 'open',
-                args: ['-a', 'Warp'],
-                name: 'Warp',
-                openCommand: ['open', '-a', 'Warp', '${cwd}'],
-            },
-        };
-    }
-    /**
-     * Apply editor preset configuration
-     */
-    async applyEditorPreset(presetName) {
-        const presets = this.getEditorPresets();
-        const preset = presets[presetName];
-        if (!preset) {
-            return {
-                success: false,
-                errors: [
-                    { path: ['development', 'editor'], message: `Unknown editor preset: ${presetName}` },
-                ],
-            };
-        }
-        return this.updateSettings([
-            {
-                path: ['development', 'editor'],
-                value: preset,
-            },
-        ]);
-    }
-    /**
-     * Apply terminal preset configuration
-     */
-    async applyTerminalPreset(presetName) {
-        const presets = this.getTerminalPresets();
-        const preset = presets[presetName];
-        if (!preset) {
-            return {
-                success: false,
-                errors: [
-                    { path: ['development', 'terminal'], message: `Unknown terminal preset: ${presetName}` },
-                ],
-            };
-        }
-        return this.updateSettings([
-            {
-                path: ['development', 'terminal'],
-                value: preset,
-            },
-        ]);
-    }
-    /**
-     * Generate command to open a file with the configured editor
-     */
-    getOpenFileCommand(filePath) {
-        const editor = this.settings.development?.editor;
-        if (!editor?.openFileCommand)
-            return null;
-        return editor.openFileCommand.map((arg) => arg.replace('${file}', filePath));
-    }
-    /**
-     * Generate command to open a folder with the configured editor
-     */
-    getOpenFolderCommand(folderPath) {
-        const editor = this.settings.development?.editor;
-        if (!editor?.openFolderCommand)
-            return null;
-        return editor.openFolderCommand.map((arg) => arg.replace('${folder}', folderPath));
-    }
-    /**
-     * Generate command to open terminal in specific directory
-     */
-    getOpenTerminalCommand(cwd) {
-        const terminal = this.settings.development?.terminal;
-        if (!terminal?.openCommand)
-            return null;
-        return terminal.openCommand.map((arg) => arg.replace('${cwd}', cwd));
-    }
-    /**
-     * Validate if editor is available on system
-     */
-    async validateEditorAvailability() {
-        const editor = this.settings.development?.editor;
-        if (!editor?.command) {
-            return { available: false, error: 'No editor command configured' };
-        }
-        try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
-            // Try to get version or check if command exists
-            await execAsync(`which ${editor.command}`, { timeout: 5000 });
-            return { available: true };
-        }
-        catch {
-            return {
-                available: false,
-                error: `Editor command '${editor.command}' not found in PATH`,
-            };
-        }
-    }
-    /**
-     * Validate if terminal is available on system
-     */
-    async validateTerminalAvailability() {
-        const terminal = this.settings.development?.terminal;
-        if (!terminal?.command) {
-            return { available: false, error: 'No terminal command configured' };
-        }
-        try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
-            // Try to check if command exists
-            await execAsync(`which ${terminal.command}`, { timeout: 5000 });
-            return { available: true };
-        }
-        catch {
-            return {
-                available: false,
-                error: `Terminal command '${terminal.command}' not found in PATH`,
-            };
-        }
-    }
-    // Private methods
-    async ensureSettingsDirectory() {
-        const settingsDir = path.dirname(this.settingsPath);
-        try {
-            await fs.access(settingsDir);
-        }
-        catch {
-            await fs.mkdir(settingsDir, { recursive: true });
-            log.info('Created settings directory', { settingsDir }, 'settings-service');
-        }
-    }
-    async loadSettings() {
-        try {
-            await fs.access(this.settingsPath);
-            const data = await fs.readFile(this.settingsPath, 'utf-8');
-            const parsed = JSON.parse(data);
-            // Validate and merge with defaults
-            const validated = VibemanSettingsSchema.parse(parsed);
-            this.settings = this.mergeWithDefaults(validated);
-            log.info('Settings loaded from file', { settingsPath: this.settingsPath }, 'settings-service');
-        }
-        catch (error) {
-            log.info('Settings file not found or invalid, using defaults', { error: String(error) }, 'settings-service');
-            this.settings = { ...DEFAULT_SETTINGS };
-            await this.saveSettings();
-        }
-    }
-    async saveSettings() {
-        const data = JSON.stringify(this.settings, null, 2);
-        await fs.writeFile(this.settingsPath, data, 'utf-8');
-        log.debug('Settings saved to file', { settingsPath: this.settingsPath }, 'settings-service');
-    }
-    async fileExists(filePath) {
-        try {
-            await fs.access(filePath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    mergeWithDefaults(settings) {
-        // Deep merge settings with defaults to handle missing properties
-        return {
-            ...DEFAULT_SETTINGS,
-            ...settings,
-            agents: {
-                ...DEFAULT_SETTINGS.agents,
-                ...settings.agents,
-                codingAgent: {
-                    ...DEFAULT_SETTINGS.agents.codingAgent,
-                    ...settings.agents?.codingAgent,
-                },
-                judgeAgent: {
-                    ...DEFAULT_SETTINGS.agents.judgeAgent,
-                    ...settings.agents?.judgeAgent,
-                },
-                providers: {
-                    ...(DEFAULT_SETTINGS.agents.providers ?? {}),
-                    ...(settings.agents?.providers ?? {}),
-                },
-                defaultPrompts: {
-                    ...DEFAULT_SETTINGS.agents.defaultPrompts,
-                    ...settings.agents?.defaultPrompts,
-                },
-                routingPolicy: {
-                    ...DEFAULT_SETTINGS.agents.routingPolicy,
-                    ...settings.agents?.routingPolicy,
-                    operations: {
-                        ...(DEFAULT_SETTINGS.agents.routingPolicy?.operations ?? {}),
-                        ...(settings.agents?.routingPolicy?.operations ?? {}),
-                    },
-                },
-            },
-            defaultWorkflow: {
-                ...DEFAULT_SETTINGS.defaultWorkflow,
-                ...settings.defaultWorkflow,
-            },
-            quality: {
-                ...DEFAULT_SETTINGS.quality,
-                ...settings.quality,
-                checks: (settings.quality?.checks ?? DEFAULT_SETTINGS.quality?.checks),
-            },
-            development: {
-                ...DEFAULT_SETTINGS.development,
-                ...settings.development,
-                git: {
-                    ...DEFAULT_SETTINGS.development.git,
-                    ...settings.development?.git,
-                },
-                editor: {
-                    ...DEFAULT_SETTINGS.development.editor,
-                    ...settings.development?.editor,
-                },
-                terminal: {
-                    ...DEFAULT_SETTINGS.development.terminal,
-                    ...settings.development?.terminal,
-                },
-            },
-            server: {
-                ...DEFAULT_SETTINGS.server,
-                ...settings.server,
-            },
-        };
-    }
-    applySingleUpdate(target, path, value) {
-        if (path.length === 0) {
-            throw new Error('Empty path not allowed');
-        }
-        if (path.length === 1) {
-            target[path[0]] = value;
-            return;
-        }
-        const [head, ...tail] = path;
-        if (!target[head] || typeof target[head] !== 'object') {
-            target[head] = {};
-        }
-        this.applySingleUpdate(target[head], tail, value);
-    }
-}
-// Singleton instance
-let settingsService = null;
-export function getSettingsService(config) {
-    settingsService ?? (settingsService = new SettingsService(config));
-    return settingsService;
-}

package/dist/runtime/api/tasks/file-watcher.d.ts

@@ -1,23 +0,0 @@
-import { EventEmitter } from 'events';
-export interface FileWatcherOptions {
-    recursive?: boolean;
-    debounceMs?: number;
-    fileFilter?: (filename: string) => boolean;
-}
-export interface FileChangeEvent {
-    type: 'created' | 'updated' | 'deleted';
-    filename: string;
-    fullPath: string;
-}
-export declare class FileWatcher extends EventEmitter {
-    private watcher;
-    private watchDir;
-    private options;
-    private pendingChanges;
-    constructor(watchDir: string, options?: FileWatcherOptions);
-    start(): void;
-    stop(): void;
-    private debounceFileChange;
-    private handleFileChange;
-    private fileExists;
-}