vibeman 0.0.0 → 0.0.1

package/dist/runtime/api/agent/core-agent-service.js

@@ -0,0 +1,267 @@
+/**
+ * Core Agent Service - Pure AI Execution Engine
+ * Provider-agnostic AI execution service
+ */
+import { EventEmitter } from 'events';
+import { log } from '../lib/logger.js';
+import { generateId } from '../lib/id-generator.js';
+/**
+ * Pure AI Execution Service
+ * Manages AI providers and executions without business logic
+ */
+export class CoreAgentService extends EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.providers = new Map();
+        this.defaultProvider = null;
+        this.executions = new Map();
+        this.config = {
+            executionTimeout: config.executionTimeout || 30 * 60 * 1000, // 30 minutes
+            ...config,
+        };
+    }
+    /**
+     * Register an AI provider
+     */
+    registerProvider(name, provider) {
+        this.providers.set(name, provider);
+        log.debug(`Registered AI provider: ${name}`, undefined, 'core-agent-service');
+        // Set as default if it's the first provider or matches config
+        if (!this.defaultProvider || name === this.config.defaultProvider) {
+            this.defaultProvider = name;
+            log.debug(`Set default provider: ${name}`, undefined, 'core-agent-service');
+        }
+    }
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(name) {
+        if (!this.providers.has(name)) {
+            throw new Error(`Provider ${name} not registered`);
+        }
+        this.defaultProvider = name;
+        log.debug(`Changed default provider to: ${name}`, undefined, 'core-agent-service');
+    }
+    /**
+     * Get default provider name
+     */
+    getDefaultProvider() {
+        return this.defaultProvider;
+    }
+    /**
+     * Get provider by name
+     */
+    getProvider(name) {
+        return this.providers.get(name) || null;
+    }
+    /**
+     * Get all registered providers
+     */
+    getProviders() {
+        return new Map(this.providers);
+    }
+    /**
+     * Execute a prompt with streaming
+     */
+    async execute(request) {
+        // Determine which provider to use
+        const providerName = request.provider || this.defaultProvider;
+        if (!providerName) {
+            throw new Error('No provider specified and no default provider set');
+        }
+        const provider = this.providers.get(providerName);
+        if (!provider) {
+            throw new Error(`Provider ${providerName} not found`);
+        }
+        const executionId = request.executionId || this.generateExecutionId();
+        const abortController = new AbortController();
+        // Set timeout
+        const timeoutId = setTimeout(() => {
+            abortController.abort();
+        }, this.config.executionTimeout);
+        const execution = {
+            id: executionId,
+            provider: provider.name,
+            status: 'pending',
+            startTime: new Date().toISOString(),
+            messages: [],
+            abortController,
+        };
+        this.executions.set(executionId, execution);
+        // Emit execution created event
+        this.emit('executionCreated', { executionId, provider: execution.provider });
+        try {
+            execution.status = 'running';
+            this.emit('executionStarted', { executionId });
+            const options = {
+                ...request.options,
+                abortSignal: abortController.signal,
+            };
+            let result = '';
+            const messages = [];
+            // Execute with streaming
+            for await (const message of provider.execute(request.prompt, options)) {
+                execution.messages.push(message);
+                // Emit message events
+                this.emit('executionMessage', {
+                    executionId,
+                    message,
+                });
+                // Collect assistant messages
+                if (message.type === 'assistant') {
+                    const content = message.content;
+                    messages.push(content);
+                    // Emit update for UI streaming
+                    this.emit('executionUpdate', {
+                        executionId,
+                        status: execution.status,
+                        message,
+                    });
+                }
+                // Handle result
+                if (message.type === 'result') {
+                    const resultMsg = message;
+                    if (resultMsg.success) {
+                        result = resultMsg.result || messages.join('\n');
+                        execution.result = result;
+                        execution.usage = resultMsg.usage;
+                    }
+                    else {
+                        throw new Error(resultMsg.error || 'Execution failed');
+                    }
+                }
+            }
+            // Mark as completed
+            execution.status = 'completed';
+            execution.endTime = new Date().toISOString();
+            clearTimeout(timeoutId);
+            // Emit completion event
+            this.emit('executionCompleted', {
+                executionId,
+                result,
+                usage: execution.usage,
+            });
+            return result;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            // Handle cancellation
+            if (abortController.signal.aborted) {
+                execution.status = 'cancelled';
+                execution.error = 'Execution cancelled';
+                this.emit('executionCancelled', { executionId });
+            }
+            else {
+                execution.status = 'failed';
+                execution.error = error instanceof Error ? error.message : String(error);
+                this.emit('executionFailed', {
+                    executionId,
+                    error: execution.error,
+                });
+            }
+            execution.endTime = new Date().toISOString();
+            throw error;
+        }
+    }
+    /**
+     * Get execution status
+     */
+    getExecutionStatus(executionId) {
+        const execution = this.executions.get(executionId);
+        if (!execution)
+            return null;
+        // Return copy without internal fields
+        const { abortController, ...publicState } = execution;
+        return publicState;
+    }
+    /**
+     * Get execution messages
+     */
+    getExecutionMessages(executionId) {
+        const execution = this.executions.get(executionId);
+        return execution ? [...execution.messages] : [];
+    }
+    /**
+     * Stop an execution
+     */
+    async stopExecution(executionId) {
+        const execution = this.executions.get(executionId);
+        if (!execution) {
+            throw new Error(`Execution ${executionId} not found`);
+        }
+        if (execution.status !== 'running') {
+            throw new Error(`Execution ${executionId} is not running`);
+        }
+        if (execution.abortController) {
+            execution.abortController.abort();
+            execution.status = 'cancelled';
+            execution.endTime = new Date().toISOString();
+            this.emit('executionCancelled', { executionId });
+        }
+    }
+    /**
+     * Get all executions
+     */
+    getAllExecutions() {
+        return Array.from(this.executions.values()).map((e) => {
+            const { abortController, ...publicState } = e;
+            return publicState;
+        });
+    }
+    /**
+     * Clear completed executions
+     */
+    clearCompletedExecutions() {
+        let cleared = 0;
+        for (const [id, execution] of this.executions) {
+            if (['completed', 'failed', 'cancelled'].includes(execution.status)) {
+                this.executions.delete(id);
+                cleared++;
+            }
+        }
+        return cleared;
+    }
+    /**
+     * Validate all providers
+     */
+    async validateProviders() {
+        const results = new Map();
+        for (const [name, provider] of this.providers) {
+            try {
+                const status = await provider.validateSetup();
+                results.set(name, status);
+            }
+            catch (error) {
+                results.set(name, {
+                    available: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    models: [],
+                    capabilities: provider.getCapabilities(),
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Get available models from all providers
+     */
+    async getAvailableModels() {
+        const models = [];
+        for (const [name, provider] of this.providers) {
+            try {
+                const providerModels = await provider.detectAvailableModels();
+                models.push(...providerModels);
+            }
+            catch (error) {
+                log.warn(`Failed to get models from provider ${name}`, error, 'core-agent-service');
+            }
+        }
+        return models;
+    }
+    /**
+     * Generate execution ID
+     */
+    generateExecutionId() {
+        return generateId('exec');
+    }
+}

package/dist/runtime/api/agent/parsers.d.ts

@@ -0,0 +1,15 @@
+export declare function parseImprovementResult(result: string, originalData: {
+    title: string;
+    type: string;
+    priority: string;
+    content: string;
+}): {
+    type: string;
+    priority: string;
+    content: string;
+};
+export declare function parseReviewResult(result: string): {
+    reviewSummary: string;
+    recommendations: string[];
+    qualityScore: number;
+};

package/dist/runtime/api/agent/parsers.js

@@ -0,0 +1,241 @@
+import { log } from '../lib/logger.js';
+// Extract the last valid JSON object from mixed text.
+// It scans for fenced ```json blocks and balanced-brace objects, then returns the last one that parses.
+function extractLastValidJson(text) {
+    if (!text)
+        return null;
+    const candidates = [];
+    // 1) Fenced JSON blocks
+    const fencedRe = /```json\s*([\s\S]*?)\s*```/gi;
+    let m;
+    while ((m = fencedRe.exec(text)) !== null) {
+        if (m[1])
+            candidates.push(m[1]);
+    }
+    // 2) Balanced brace objects
+    let depth = 0;
+    let inStr = false;
+    let start = -1;
+    let prev = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inStr) {
+            if (ch === '"' && prev !== '\\')
+                inStr = false;
+        }
+        else {
+            if (ch === '"')
+                inStr = true;
+            else if (ch === '{') {
+                if (depth === 0)
+                    start = i;
+                depth++;
+            }
+            else if (ch === '}') {
+                if (depth > 0)
+                    depth--;
+                if (depth === 0 && start >= 0) {
+                    candidates.push(text.slice(start, i + 1));
+                    start = -1;
+                }
+            }
+        }
+        prev = ch;
+    }
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        const c = candidates[i].trim();
+        try {
+            JSON.parse(c);
+            return c;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return null;
+}
+/**
+ * Manually parse a JSON-like structure that may have unescaped strings
+ * This is a fallback for when JSON.parse fails due to unescaped content
+ */
+function parseJsonManually(jsonStr) {
+    try {
+        // Extract type and priority with simple regex (these are usually well-formed)
+        const typeMatch = jsonStr.match(/"type":\s*"([^"]+)"/);
+        const priorityMatch = jsonStr.match(/"priority":\s*"([^"]+)"/);
+        // For content, find the start and extract everything until the closing brace
+        const contentStart = jsonStr.indexOf('"content":');
+        if (contentStart === -1)
+            return null;
+        const contentValueStart = jsonStr.indexOf('"', contentStart + 10);
+        if (contentValueStart === -1)
+            return null;
+        // Find the last occurrence of "}` at the end - this marks the end of our JSON
+        const jsonEnd = jsonStr.lastIndexOf('}');
+        if (jsonEnd === -1)
+            return null;
+        // Find the quote that comes before the closing brace
+        // Work backwards from the closing brace to find the last quote
+        let contentEnd = -1;
+        for (let i = jsonEnd - 1; i > contentValueStart; i--) {
+            if (jsonStr[i] === '"') {
+                // Check if this quote is escaped
+                let backslashCount = 0;
+                for (let j = i - 1; j >= 0 && jsonStr[j] === '\\'; j--) {
+                    backslashCount++;
+                }
+                // If even number of backslashes (including 0), quote is not escaped
+                if (backslashCount % 2 === 0) {
+                    contentEnd = i;
+                    break;
+                }
+            }
+        }
+        if (contentEnd === -1)
+            return null;
+        // Extract the raw content
+        const rawContent = jsonStr.substring(contentValueStart + 1, contentEnd);
+        if (typeMatch && priorityMatch && rawContent) {
+            // Clean up the content - unescape common escape sequences
+            const content = rawContent
+                .replace(/\\n/g, '\n')
+                .replace(/\\r/g, '\r')
+                .replace(/\\t/g, '\t')
+                .replace(/\\"/g, '"')
+                .replace(/\\\\/g, '\\');
+            return {
+                type: typeMatch[1],
+                priority: priorityMatch[1],
+                content: content,
+            };
+        }
+        return null;
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        log.warn('Manual JSON parsing failed', { error: errMsg }, 'result-parsers');
+        return null;
+    }
+}
+export function parseImprovementResult(result, originalData) {
+    try {
+        const jsonBlock = extractLastValidJson(result);
+        if (jsonBlock) {
+            // Try parsing as-is first
+            try {
+                const parsed = JSON.parse(jsonBlock);
+                if (parsed.type && parsed.priority && parsed.content) {
+                    // Validate type and priority values
+                    const validTypes = ['feature', 'bug', 'chore', 'refactor', 'test', 'doc'];
+                    const validPriorities = ['high', 'medium', 'low'];
+                    const normalizedType = String(parsed.type).toLowerCase();
+                    const normalizedPriority = String(parsed.priority).toLowerCase();
+                    return {
+                        type: validTypes.includes(normalizedType) ? normalizedType : originalData.type,
+                        priority: validPriorities.includes(normalizedPriority)
+                            ? normalizedPriority
+                            : originalData.priority,
+                        content: String(parsed.content).trim(),
+                    };
+                }
+            }
+            catch (parseError) {
+                // If JSON parsing fails, try to fix common issues
+                const parseErrMsg = parseError instanceof Error ? parseError.message : String(parseError);
+                log.warn('Initial JSON parse failed, attempting to clean JSON', { error: parseErrMsg }, 'result-parsers');
+                try {
+                    // Attempt to manually parse the JSON structure
+                    const parsed = parseJsonManually(jsonBlock);
+                    if (parsed && parsed.type && parsed.priority && parsed.content) {
+                        const validTypes = ['feature', 'bug', 'chore', 'refactor', 'test', 'doc'];
+                        const validPriorities = ['high', 'medium', 'low'];
+                        const normalizedType = String(parsed.type).toLowerCase();
+                        const normalizedPriority = String(parsed.priority).toLowerCase();
+                        return {
+                            type: validTypes.includes(normalizedType) ? normalizedType : originalData.type,
+                            priority: validPriorities.includes(normalizedPriority)
+                                ? normalizedPriority
+                                : originalData.priority,
+                            content: String(parsed.content).trim(),
+                        };
+                    }
+                }
+                catch (secondError) {
+                    const secondErrMsg = secondError instanceof Error ? secondError.message : String(secondError);
+                    log.error('JSON cleaning also failed', { error: secondErrMsg }, 'result-parsers');
+                }
+            }
+        }
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        log.error('Failed to parse improvement result', { error: errMsg, result }, 'result-parsers');
+    }
+    return {
+        type: originalData.type,
+        priority: originalData.priority,
+        content: result.trim() || originalData.content,
+    };
+}
+export function parseReviewResult(result) {
+    try {
+        const jsonBlock = extractLastValidJson(result);
+        if (jsonBlock) {
+            const parsed = JSON.parse(jsonBlock);
+            if (parsed.reviewSummary &&
+                parsed.recommendations &&
+                (typeof parsed.qualityScore === 'number' || typeof parsed.score === 'number')) {
+                const score = typeof parsed.qualityScore === 'number' ? parsed.qualityScore : parsed.score;
+                return {
+                    reviewSummary: String(parsed.reviewSummary),
+                    recommendations: Array.isArray(parsed.recommendations)
+                        ? parsed.recommendations.map((r) => String(r))
+                        : [String(parsed.recommendations)],
+                    qualityScore: Math.max(0, Math.min(100, Number(score))),
+                };
+            }
+        }
+    }
+    catch (error) {
+        log.error('Failed to parse review result', error, 'result-parsers');
+    }
+    // Fallback: parse simple plaintext format like
+    // Score: 75/100\nSummary: ...\nRecommendations:\n- item
+    try {
+        const scoreMatch = result.match(/Score\s*:\s*(\d{1,3})(?:\s*\/\s*100)?/i);
+        const summaryMatch = result.match(/Summary\s*:\s*([\s\S]*?)(?:\n\s*Recommendations\s*:|$)/i);
+        const recBlockMatch = result.match(/Recommendations\s*:\s*([\s\S]*)$/i);
+        const score = scoreMatch ? Math.max(0, Math.min(100, Number(scoreMatch[1]))) : 75;
+        const reviewSummary = summaryMatch
+            ? summaryMatch[1].trim()
+            : result.length > 200
+                ? result.substring(0, 200) + '...'
+                : result;
+        let recommendations = [];
+        if (recBlockMatch) {
+            const lines = recBlockMatch[1]
+                .split(/\r?\n/)
+                .map((l) => l.trim())
+                .filter(Boolean);
+            // Take bullet-like lines or fallback to one-liner
+            const bullets = lines
+                .filter((l) => /^[-*•\d]/.test(l))
+                .map((l) => l.replace(/^[-*•\d.)\s]+/, '').trim());
+            recommendations = bullets.length ? bullets : lines.slice(0, 5);
+            if (!recommendations.length)
+                recommendations = ['Review completed - see output for details'];
+        }
+        else {
+            recommendations = ['Review completed - see output for details'];
+        }
+        return { reviewSummary, recommendations, qualityScore: score };
+    }
+    catch {
+        // fall back to generic
+    }
+    return {
+        reviewSummary: result.length > 200 ? result.substring(0, 200) + '...' : result,
+        recommendations: ['Review completed - see output for details'],
+        qualityScore: 75,
+    };
+}

package/dist/runtime/api/agent/prompt-service.d.ts

@@ -0,0 +1,17 @@
+import type { Task, WorktreeInfo } from '../types/index.js';
+import type { TaskService } from '../tasks/task-service.js';
+export declare class PromptService {
+    private projectRoot;
+    private taskService;
+    constructor(projectRoot: string, taskService: TaskService);
+    generateImprovementPrompt(task: Task, taskData: {
+        title: string;
+        type: string;
+        priority: string;
+        content: string;
+    }): Promise<string>;
+    generateTaskPrompt(task: Task): Promise<string>;
+    generateAIMergePrompt(task: Task, worktree: WorktreeInfo, baseBranch?: string): Promise<string>;
+    generateReviewPrompt(task: Task, worktree: WorktreeInfo, reviewContext?: string): Promise<string>;
+}
+export declare function getQualityChecksDetectionPrompt(): string;