vibeman 0.0.0 → 0.0.1

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

@@ -0,0 +1,611 @@
+/**
+ * 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 MODEL_ENUM = [...CLAUDE_ALLOWED_MODELS, 'gpt-5'];
+const VibemanSettingsSchema = z.object({
+    agents: z.object({
+        defaultProvider: z.enum(['claude-code', 'codex']),
+        codingAgent: z.object({
+            provider: z.enum(['claude-code', 'codex']),
+            model: z.enum(MODEL_ENUM),
+            maxTokens: z.number().min(256).max(10000000000000).optional(),
+        }),
+        judgeAgent: z.object({
+            provider: z.enum(['claude-code', 'codex']),
+            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),
+        }),
+        providers: z
+            .object({
+            claudeCode: z.object({ binPath: z.string().min(1).optional() }).optional(),
+            codex: z.object({ binPath: z.string().min(1).optional() }).optional(),
+        })
+            .optional(),
+    }),
+    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: {},
+    },
+    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';
+        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,
+                },
+            },
+            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

@@ -0,0 +1,23 @@
+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;
+}