vibeman 0.0.3 → 0.0.6

package/dist/runtime/api/workflows/quality-pipeline.js

@@ -1,400 +0,0 @@
-import { spawn } from 'child_process';
-import { stripNextInjectedEnv } from '../utils/stripNextEnv.js';
-import { log } from '../lib/logger.js';
-import { getSettingsService } from '../settings-service.js';
-import { CoreAgentService } from '../agent/core-agent-service.js';
-import { ClaudeCodeAdapter, CodexCliProvider } from '../agent/ai-providers/index.js';
-import { getQualityChecksDetectionPrompt } from '../agent/prompt-service.js';
-export class QualityPipeline {
-    // Expose configured checks for external orchestration/streaming
-    async getChecksFor() {
-        return await this.getChecks();
-    }
-    // Load checks from settings only. If none are configured, return an empty list
-    // so validation is skipped by default. Auto-detection should be an explicit user action
-    // (via Settings → Detect Quality Checks) rather than an implicit fallback.
-    async getChecks() {
-        const settingsService = getSettingsService();
-        await settingsService.initialize();
-        const settings = settingsService.getSettings();
-        const configured = settings.quality?.checks || [];
-        if (configured.length === 0)
-            return [];
-        return configured
-            .filter((c) => c.enabled !== false)
-            .map((c) => ({
-            name: c.name,
-            command: c.command,
-            args: c.args ?? [],
-            timeout: c.timeout ?? 30000,
-        }));
-    }
-    async detectQualityChecks(cwd) {
-        // AI-only detection. If AI fails or returns nothing, we skip validation.
-        try {
-            const aiChecks = await this.aiDetectQualityChecks(cwd);
-            return Array.isArray(aiChecks) ? aiChecks : [];
-        }
-        catch (e) {
-            log.error('AI detection failed; no quality checks will be used', e, 'quality-pipeline:detect');
-            return [];
-        }
-    }
-    async aiDetectQualityChecks(cwd) {
-        const prompt = getQualityChecksDetectionPrompt();
-        const core = new CoreAgentService({ defaultProvider: this.getDefaultProviderName() });
-        core.registerProvider('claude-code', new ClaudeCodeAdapter({
-            defaultWorkingDirectory: cwd,
-            defaultModel: 'claude-sonnet-4-20250514',
-        }));
-        core.registerProvider('codex', new CodexCliProvider({ defaultWorkingDirectory: cwd }));
-        const tools = ['Read', 'Grep', 'Glob'];
-        const result = await core.execute({
-            prompt,
-            options: {
-                workingDirectory: cwd,
-                tools,
-                maxTokens: 2000,
-            },
-        });
-        const jsonStart = result.indexOf('{');
-        const jsonEnd = result.lastIndexOf('}');
-        if (jsonStart === -1 || jsonEnd === -1)
-            throw new Error('No JSON in AI output');
-        const text = result.slice(jsonStart, jsonEnd + 1);
-        const parsed = JSON.parse(text);
-        const items = (parsed.checks || []).filter((c) => c && c.name && c.command);
-        return items.map((c) => ({
-            name: c.name,
-            command: c.command,
-            args: Array.isArray(c.args) ? c.args : [],
-            timeout: typeof c.timeout === 'number' ? c.timeout : 30000,
-        }));
-    }
-    getDefaultProviderName() {
-        try {
-            const s = getSettingsService().getSettings();
-            return s.agents?.defaultProvider || 'claude-code';
-        }
-        catch {
-            return 'claude-code';
-        }
-    }
-    /**
-     * Public: Detect quality checks (AI-only) and persist to settings if found.
-     * Does not execute any checks.
-     */
-    async detectAndPersistChecks(workingDirectory) {
-        const settingsService = getSettingsService();
-        await settingsService.initialize();
-        const detected = await this.detectQualityChecks(workingDirectory);
-        const result = detected.map((d) => ({ ...d, enabled: true }));
-        if (result.length > 0) {
-            try {
-                await settingsService.updateSettings([{ path: ['quality', 'checks'], value: result }]);
-            }
-            catch (err) {
-                log.warn('Failed to persist detected quality checks', err, 'quality-pipeline:detectPersist');
-            }
-        }
-        return result;
-    }
-    /**
-     * Run all quality checks in the specified directory
-     */
-    async runChecks(workingDirectory) {
-        log.info(`Running quality checks in ${workingDirectory}`, { workingDirectory }, 'quality-pipeline:runChecks');
-        const startTime = Date.now();
-        // Run checks sequentially to avoid race conditions between tools
-        const details = {};
-        const outputs = {};
-        let overall = true;
-        const checks = await this.getChecks();
-        if (!checks || checks.length === 0) {
-            log.info('No quality checks detected; skipping validation', { workingDirectory }, 'quality-pipeline:runChecks');
-            return {
-                overall: true,
-                timestamp: new Date().toISOString(),
-                details: {},
-                outputs: { skipped: 'No quality checks configured or detected. Skipping validation.' },
-            };
-        }
-        for (const check of checks) {
-            const result = await this.runCheck(check, workingDirectory);
-            details[check.name] = result.passed;
-            outputs[check.name] = result.output;
-            if (!result.passed)
-                overall = false;
-        }
-        const results = {
-            overall,
-            timestamp: new Date().toISOString(),
-            details,
-            outputs,
-        };
-        const duration = Date.now() - startTime;
-        log.info(`Quality checks completed in ${duration}ms`, {
-            workingDirectory,
-            duration,
-            overall,
-            status: overall ? 'PASSED' : 'FAILED',
-            results: results.details,
-        }, 'quality-pipeline:runChecks');
-        return results;
-    }
-    /**
-     * Run checks with streaming logs via callback.
-     */
-    async runChecksStreaming(workingDirectory, onLog) {
-        const startTime = Date.now();
-        const details = {};
-        const outputs = {};
-        let overall = true;
-        const checks = await this.getChecks();
-        if (!checks || checks.length === 0) {
-            onLog?.('[validation] No quality checks configured or detected. Skipping validation.');
-            return {
-                overall: true,
-                timestamp: new Date().toISOString(),
-                details: {},
-                outputs: { skipped: 'No quality checks configured or detected. Skipping validation.' },
-            };
-        }
-        for (const check of checks) {
-            if (onLog)
-                await onLog(`== ${check.name.toUpperCase()}: START ==`);
-            try {
-                const output = await this.runCommandStreaming(check.command, check.args, workingDirectory, check.timeout, (chunk) => onLog?.(String(chunk)));
-                details[check.name] = true;
-                outputs[check.name] = output.trim();
-                if (onLog)
-                    await onLog(`== ${check.name.toUpperCase()}: PASSED ==`);
-            }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                const isMissing = this.isMissingCommandError(msg);
-                if (isMissing) {
-                    details[check.name] = true;
-                    outputs[check.name] = `Skipped: command unavailable. ${msg}`;
-                    if (onLog)
-                        await onLog(`== ${check.name.toUpperCase()}: SKIPPED (missing command) ==`);
-                }
-                else {
-                    details[check.name] = false;
-                    outputs[check.name] = msg;
-                    overall = false;
-                    if (onLog)
-                        await onLog(`== ${check.name.toUpperCase()}: FAILED ==`);
-                }
-            }
-        }
-        const duration = Date.now() - startTime;
-        if (onLog)
-            await onLog(`[validation] Completed in ${duration}ms. Status: ${overall ? 'PASSED' : 'FAILED'}`);
-        return {
-            overall,
-            timestamp: new Date().toISOString(),
-            details,
-            outputs,
-        };
-    }
-    /**
-     * Run a single quality check
-     */
-    async runCheck(check, workingDirectory) {
-        try {
-            const output = await this.runCommand(check.command, check.args, workingDirectory, check.timeout);
-            return {
-                passed: true,
-                output: output.trim(),
-            };
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            const isMissing = this.isMissingCommandError(msg);
-            if (isMissing) {
-                return {
-                    passed: true,
-                    output: `Skipped: command unavailable. ${msg}`,
-                };
-            }
-            return { passed: false, output: msg };
-        }
-    }
-    /**
-     * Run a command and return its output
-     */
-    runCommand(command, args, cwd, timeoutMs = 30000) {
-        return new Promise((resolve, reject) => {
-            const childProcess = spawn(command, args, {
-                cwd,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                shell: true,
-                env: {
-                    ...stripNextInjectedEnv(process.env),
-                    NODE_ENV: 'production',
-                },
-            });
-            let stdout = '';
-            let stderr = '';
-            let settled = false;
-            const cleanup = () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                clearTimeout(killTimer);
-            };
-            let killTimer;
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                // First try SIGTERM
-                childProcess.kill('SIGTERM');
-                // If process doesn't exit within 5 seconds, force kill with SIGKILL
-                killTimer = setTimeout(() => {
-                    if (!settled) {
-                        childProcess.kill('SIGKILL');
-                        cleanup();
-                        reject(new Error(`Command "${command} ${args.join(' ')}" timed out after ${timeoutMs}ms and was force killed`));
-                    }
-                }, 5000);
-                // Set timeout error
-                setTimeout(() => {
-                    if (!settled) {
-                        cleanup();
-                        reject(new Error(`Command "${command} ${args.join(' ')}" timed out after ${timeoutMs}ms`));
-                    }
-                }, 100);
-            }, timeoutMs);
-            childProcess.stdout?.on('data', (data) => {
-                stdout += data.toString();
-            });
-            childProcess.stderr?.on('data', (data) => {
-                stderr += data.toString();
-            });
-            childProcess.on('close', (code) => {
-                cleanup();
-                const output = stdout + (stderr ? `\n--- STDERR ---\n${stderr}` : '');
-                if (code === 0) {
-                    resolve(output);
-                }
-                else {
-                    reject(new Error(`Command "${command} ${args.join(' ')}" failed with code ${code}\n${output}`));
-                }
-            });
-            childProcess.on('error', (error) => {
-                cleanup();
-                reject(error);
-            });
-        });
-    }
-    runCommandStreaming(command, args, cwd, timeoutMs = 30000, onChunk) {
-        return new Promise((resolve, reject) => {
-            const childProcess = spawn(command, args, {
-                cwd,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                shell: true,
-                env: {
-                    ...stripNextInjectedEnv(process.env),
-                    NODE_ENV: 'production',
-                },
-            });
-            let stdout = '';
-            let stderr = '';
-            let settled = false;
-            const pending = [];
-            const cleanup = () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                clearTimeout(killTimer);
-            };
-            let killTimer;
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                childProcess.kill('SIGTERM');
-                killTimer = setTimeout(() => {
-                    if (!settled) {
-                        childProcess.kill('SIGKILL');
-                        cleanup();
-                        reject(new Error(`Command "${command} ${args.join(' ')}" timed out after ${timeoutMs}ms and was force killed`));
-                    }
-                }, 5000);
-                setTimeout(() => {
-                    if (!settled) {
-                        cleanup();
-                        reject(new Error(`Command "${command} ${args.join(' ')}" timed out after ${timeoutMs}ms`));
-                    }
-                }, 100);
-            }, timeoutMs);
-            const handleData = (buff, isErr = false) => {
-                const str = String(buff);
-                if (isErr)
-                    stderr += str;
-                else
-                    stdout += str;
-                try {
-                    const maybe = onChunk?.(str);
-                    if (maybe && typeof maybe.then === 'function') {
-                        pending.push(maybe);
-                    }
-                }
-                catch (e) {
-                    log.error('Error handling data', e, 'quality-pipeline:runCommandStreaming');
-                }
-            };
-            childProcess.stdout?.on('data', (data) => handleData(data, false));
-            childProcess.stderr?.on('data', (data) => handleData(data, true));
-            childProcess.on('close', async (code) => {
-                cleanup();
-                // Ensure all async log writes are flushed before resolving
-                try {
-                    if (pending.length)
-                        await Promise.allSettled(pending);
-                }
-                catch (e) {
-                    log.error('Error setting pending', e, 'quality-pipeline:runCommandStreaming');
-                }
-                const output = stdout + (stderr ? `\n--- STDERR ---\n${stderr}` : '');
-                if (code === 0)
-                    resolve(output);
-                else
-                    reject(new Error(`Command "${command} ${args.join(' ')}" failed with code ${code}\n${output}`));
-            });
-            childProcess.on('error', (error) => {
-                cleanup();
-                reject(error);
-            });
-        });
-    }
-    isMissingCommandError(message) {
-        const m = message.toLowerCase();
-        return (m.includes('enoent') ||
-            m.includes('command not found') ||
-            m.includes('not recognized as an internal or external command') ||
-            m.includes('missing script'));
-    }
-    /**
-     * Run individual quality check by name
-     */
-    async runSingleCheck(checkName, workingDirectory) {
-        const checks = await this.getChecks();
-        const check = checks.find((c) => c.name === checkName);
-        if (!check) {
-            throw new Error(`Unknown check: ${checkName}`);
-        }
-        return this.runCheck(check, workingDirectory);
-    }
-    /**
-     * Get quality pipeline configuration
-     */
-    getConfig() {
-        return {
-            checks: [],
-            parallel: false,
-        };
-    }
-}