vibeman 0.0.5 → 0.0.6

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

@@ -1,267 +0,0 @@
-/**
- * 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

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

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

@@ -1,308 +0,0 @@
-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, priority and title with simple regex (these are usually well-formed)
-        const typeMatch = jsonStr.match(/"type":\s*"([^"]+)"/);
-        const priorityMatch = jsonStr.match(/"priority":\s*"([^"]+)"/);
-        const titleMatch = jsonStr.match(/"title":\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, '\\');
-            const result = {
-                type: typeMatch[1],
-                priority: priorityMatch[1],
-                content: content,
-            };
-            // Add title if found
-            if (titleMatch) {
-                result.title = titleMatch[1];
-            }
-            return result;
-        }
-        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;
-    }
-}
-/**
- * Extract title from markdown content and remove it from content
- * Returns { title: string | null, cleanedContent: string }
- */
-function extractTitleFromContent(content) {
-    if (!content || typeof content !== 'string') {
-        return { title: null, cleanedContent: content };
-    }
-    // Look for H1 heading at the start of content (with optional whitespace)
-    const h1Match = content.match(/^\s*#\s+([^\n\r]+)/);
-    if (h1Match) {
-        const title = h1Match[1].trim();
-        // Remove the H1 heading from content
-        const cleanedContent = content.replace(/^\s*#\s+[^\n\r]+\s*\n?/, '').trim();
-        return { title, cleanedContent };
-    }
-    return { title: null, cleanedContent: content };
-}
-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();
-                    // Extract title from JSON if present, otherwise from content
-                    let finalTitle;
-                    let finalContent = String(parsed.content).trim();
-                    if (parsed.title && typeof parsed.title === 'string' && parsed.title.trim()) {
-                        finalTitle = parsed.title.trim();
-                    }
-                    else {
-                        // Try to extract title from content
-                        const { title, cleanedContent } = extractTitleFromContent(finalContent);
-                        if (title) {
-                            finalTitle = title;
-                            finalContent = cleanedContent;
-                        }
-                    }
-                    const result = {
-                        type: validTypes.includes(normalizedType) ? normalizedType : originalData.type,
-                        priority: validPriorities.includes(normalizedPriority)
-                            ? normalizedPriority
-                            : originalData.priority,
-                        content: finalContent,
-                    };
-                    if (finalTitle) {
-                        result.title = finalTitle;
-                    }
-                    return result;
-                }
-            }
-            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();
-                        // Extract title from parsed JSON if present, otherwise from content
-                        let finalTitle;
-                        let finalContent = String(parsed.content).trim();
-                        if (parsed.title && typeof parsed.title === 'string' && parsed.title.trim()) {
-                            finalTitle = parsed.title.trim();
-                        }
-                        else {
-                            // Try to extract title from content
-                            const { title, cleanedContent } = extractTitleFromContent(finalContent);
-                            if (title) {
-                                finalTitle = title;
-                                finalContent = cleanedContent;
-                            }
-                        }
-                        const result = {
-                            type: validTypes.includes(normalizedType) ? normalizedType : originalData.type,
-                            priority: validPriorities.includes(normalizedPriority)
-                                ? normalizedPriority
-                                : originalData.priority,
-                            content: finalContent,
-                        };
-                        if (finalTitle) {
-                            result.title = finalTitle;
-                        }
-                        return result;
-                    }
-                }
-                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');
-    }
-    // Fallback: try to extract title from the raw result content
-    const fallbackContent = result.trim() || originalData.content;
-    const { title: extractedTitle, cleanedContent } = extractTitleFromContent(fallbackContent);
-    const fallbackResult = {
-        type: originalData.type,
-        priority: originalData.priority,
-        content: cleanedContent,
-    };
-    if (extractedTitle) {
-        fallbackResult.title = extractedTitle;
-    }
-    return fallbackResult;
-}
-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

@@ -1,30 +0,0 @@
-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);
-    /**
-     * Generate absolute path to task file
-     */
-    private generateTaskFilePath;
-    /**
-     * Validate that task file exists at the given path
-     */
-    private validateTaskFile;
-    generateImprovementPrompt(task: Task, taskData: {
-        title: string;
-        type: string;
-        priority: string;
-        content: string;
-    }): Promise<string>;
-    generateTaskPrompt(task: Task, workflowConfig?: import('../types/index.js').VibingConfig): Promise<string>;
-    /**
-     * Build a prominent, clearly formatted instruction section derived from workflow options.
-     * If no options are provided or none apply, returns a minimal guidance line.
-     */
-    private buildWorkflowInstructions;
-    generateAIMergePrompt(task: Task, worktree: WorktreeInfo, baseBranch?: string): Promise<string>;
-    generateReviewPrompt(task: Task, worktree: WorktreeInfo, reviewContext?: string): Promise<string>;
-}
-export declare function getQualityChecksDetectionPrompt(): string;