vibeman 0.0.3 → 0.0.6

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;