viberadar 0.3.57 → 0.3.59

package/dist/server/index.js

@@ -241,6 +241,147 @@ function fmtTool(name, input = {}) {
 }
 // ─── Test runner after agent ──────────────────────────────────────────────────
 const TEST_FILE_RE = /\.(test|spec)\.(ts|tsx|js|jsx)$/;
+function stripAnsi(text) {
+    return text.replace(/\u001b\[[0-9;]*m/g, '');
+}
+function extractBalancedJsonObjects(text) {
+    const result = [];
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (start === -1) {
+            if (ch === '{') {
+                start = i;
+                depth = 1;
+                inString = false;
+                escapeNext = false;
+            }
+            continue;
+        }
+        if (inString) {
+            if (escapeNext) {
+                escapeNext = false;
+            }
+            else if (ch === '\\') {
+                escapeNext = true;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === '{') {
+            depth += 1;
+            continue;
+        }
+        if (ch === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                result.push(text.slice(start, i + 1));
+                start = -1;
+            }
+        }
+    }
+    return result;
+}
+function toNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function toStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => (typeof item === 'string' ? item.trim() : ''))
+        .filter((item) => item.length > 0);
+}
+function normalizeE2eCaseId(value, index) {
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    return normalized || `e2e-case-${index + 1}`;
+}
+function sanitizeParsedE2eTestCases(value) {
+    if (!Array.isArray(value))
+        return [];
+    const usedIds = new Set();
+    const result = [];
+    for (let i = 0; i < value.length; i++) {
+        const raw = value[i];
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const item = raw;
+        const name = toNonEmptyString(item.name) ?? `E2E кейс ${i + 1}`;
+        const description = toNonEmptyString(item.description) ?? name;
+        const steps = toStringArray(item.steps);
+        const expectedResults = toStringArray(item.expectedResults);
+        if (steps.length === 0 || expectedResults.length === 0)
+            continue;
+        let idBase = normalizeE2eCaseId(toNonEmptyString(item.id) ?? `e2e-case-${i + 1}`, i);
+        let id = idBase;
+        let suffix = 2;
+        while (usedIds.has(id)) {
+            id = `${idBase}-${suffix}`;
+            suffix += 1;
+        }
+        usedIds.add(id);
+        result.push({
+            id,
+            name,
+            description,
+            steps,
+            expectedResults,
+        });
+    }
+    return result;
+}
+function parseE2ePlanFromAgentOutput(rawOutput) {
+    const cleaned = stripAnsi(rawOutput).replace(/\u0000/g, '').trim();
+    if (!cleaned) {
+        throw new Error('пустой ответ агента');
+    }
+    const candidates = [];
+    const fencedRe = /```(?:json)?\s*([\s\S]*?)```/gi;
+    let fencedMatch = null;
+    while ((fencedMatch = fencedRe.exec(cleaned)) !== null) {
+        const block = fencedMatch[1]?.trim();
+        if (block)
+            candidates.push(block);
+    }
+    candidates.push(...extractBalancedJsonObjects(cleaned));
+    candidates.push(cleaned);
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        const candidate = candidates[i];
+        let parsed;
+        try {
+            parsed = JSON.parse(candidate);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== 'object')
+            continue;
+        const obj = parsed;
+        const testCases = sanitizeParsedE2eTestCases(obj.testCases);
+        if (testCases.length === 0)
+            continue;
+        const baseUrl = toNonEmptyString(obj.baseUrl) ?? undefined;
+        return { baseUrl, testCases };
+    }
+    const hasTestCasesKey = cleaned.toLowerCase().includes('"testcases"');
+    if (hasTestCasesKey) {
+        throw new Error('ответ похож на JSON-план, но он обрезан или повреждён');
+    }
+    throw new Error('в ответе агента не найден валидный JSON с testCases');
+}
 function runTestFiles(files, projectRoot) {
     return new Promise((resolve) => {
         // Write JSON to a temp file — avoids stdout encoding/regex issues on Windows
@@ -513,14 +654,28 @@ function buildWriteTestsForSelectedPrompt(filePaths, feat, modules, testRunner)
         `Выбрано файлов (${selectedModules.length}):`,
         ...selectedLines,
         '',
-        `Требования:`,
+        `Критерии высокого стандарта (обязательно):`,
         `- Работай только с выбранными файлами из списка`,
+        `- Для КАЖДОГО выбранного файла сделай явный результат: created | updated | already-covered | blocked`,
         `- Если теста нет — создай`,
-        `- Если тест устарел — обнови`,
+        `- Если тест устарел или слабый — обнови/дополни`,
         `- Для unit файлов мокай внешние зависимости`,
         `- Для integration файлов используй test-helpers или pg-mem`,
         `- Используй ${testRunner}`,
         `- Следуй текущим паттернам тестов в проекте`,
+        `- Не завершай задачу без отчета по каждому выбранному файлу`,
+        '',
+        `Формат финального ответа (строго):`,
+        `1) "Матрица покрытия (X/${selectedModules.length})"`,
+        `   Для каждого выбранного файла отдельная строка:`,
+        `   - source: <path> | status: <created|updated|already-covered|blocked> | testFile: <path или -> | note: <что сделано/почему blocked>`,
+        `2) "Проверка"`,
+        `   - какие одноразовые команды запускал`,
+        `   - итог (сколько тестов passed/failed)`,
+        `3) "Осталось без тестов"`,
+        `   - перечисли файлы из выбранного списка, которые все еще без тестов (если есть), иначе напиши "нет"`,
+        `4) "Conventional Commit title"`,
+        `   - одна строка в формате Conventional Commits`,
     ].join('\n');
 }
 function buildRefreshTestsForSelectedPrompt(filePaths, feat, modules, testRunner) {
@@ -539,12 +694,25 @@ function buildRefreshTestsForSelectedPrompt(filePaths, feat, modules, testRunner
         `Выбрано файлов (${selectedModules.length}):`,
         ...selectedLines,
         '',
+        `Критерии высокого стандарта (обязательно):`,
+        `- Для КАЖДОГО выбранного файла дай итог: updated | already-covered | blocked`,
+        `- Не пропускай файлы молча: если не изменил, объясни почему`,
+        '',
         `Для каждого выбранного файла:`,
         `1) Проверь актуальность и качество тестов.`,
         `2) Дополни недостающие сценарии (happy path, edge cases, ошибки).`,
         `3) Если тест отсутствует — создай новый.`,
         `4) Не меняй source-код без крайней необходимости; фокус на тестах.`,
         `5) Используй ${testRunner} и паттерны проекта.`,
+        '',
+        `Формат финального ответа (строго):`,
+        `1) "Матрица покрытия (X/${selectedModules.length})"`,
+        `   - source: <path> | status: <updated|already-covered|blocked> | testFile: <path или -> | note: <кратко>`,
+        `2) "Проверка"`,
+        `   - одноразовые команды + результат`,
+        `3) "Осталось без тестов"`,
+        `   - список из выбранных, если такие остались`,
+        `4) "Conventional Commit title"`,
     ].join('\n');
 }
 function buildFixTestsPrompt(filePath, errors) {
@@ -764,6 +932,21 @@ function startServer({ data: initialData, port, projectRoot }) {
         /** Actually spawn the agent process for a queue item */
         function executeAgentItem(item) {
             const { task, featureKey, filePath, selectedFilePaths, title, agent, savedErrors, savedFailedFiles, savedTestType, autoFixAttempt = 0, autoFixSourceTask, } = item;
+            const normalizeRelPath = (p) => p.replace(/\\/g, '/');
+            const targetSourcePaths = (() => {
+                if (task === 'write-tests-file' && filePath) {
+                    return [normalizeRelPath(filePath)];
+                }
+                if ((task === 'write-tests-selected' || task === 'refresh-tests-selected') && Array.isArray(selectedFilePaths)) {
+                    return Array.from(new Set(selectedFilePaths.map(normalizeRelPath)));
+                }
+                if (task === 'write-tests' && featureKey) {
+                    return currentData.modules
+                        .filter((m) => m.featureKeys.includes(featureKey) && m.type !== 'test' && !m.hasTests && !m.isInfra)
+                        .map((m) => normalizeRelPath(m.relativePath));
+                }
+                return [];
+            })();
             // Build prompt lazily at execution time
             let prompt;
             if (task === 'write-tests') {
@@ -883,6 +1066,7 @@ function startServer({ data: initialData, port, projectRoot }) {
             const createdTestFiles = [];
             // Accumulate full result text for E2E plan parsing
             let agentResultText = '';
+            let agentRawOutputText = '';
             let queueBlockSignal = null;
             function inspectQueueBlockSignal(line) {
                 if (queueBlockSignal !== null)
@@ -918,6 +1102,9 @@ function startServer({ data: initialData, port, projectRoot }) {
             rl.on('line', (raw) => {
                 if (!raw.trim())
                     return;
+                if (task === 'generate-e2e-plan') {
+                    agentRawOutputText += raw + '\n';
+                }
                 inspectQueueBlockSignal(raw);
                 trackWrittenFiles(raw);
                 const parsed = agent === 'claude' ? parseClaudeEvent(raw) : raw;
@@ -944,6 +1131,9 @@ function startServer({ data: initialData, port, projectRoot }) {
             proc.stderr.on('data', (chunk) => {
                 const lines = chunk.toString().split('\n').filter(Boolean);
                 for (const line of lines) {
+                    if (task === 'generate-e2e-plan') {
+                        agentRawOutputText += line + '\n';
+                    }
                     inspectQueueBlockSignal(line);
                     broadcast('agent-output', { line, isError: true });
                 }
@@ -1070,8 +1260,8 @@ function startServer({ data: initialData, port, projectRoot }) {
                     // E2E plan post-processing
                     if (task === 'generate-e2e-plan' && featureKey) {
                         try {
-                            const jsonMatch = agentResultText.match(/\{[\s\S]*"testCases"[\s\S]*\}/);
-                            const parsedPlan = JSON.parse(jsonMatch ? jsonMatch[0] : agentResultText);
+                            const rawPlanOutput = agentResultText.trim().length > 0 ? agentResultText : agentRawOutputText;
+                            const parsedPlan = parseE2ePlanFromAgentOutput(rawPlanOutput);
                             const feat = currentData.features?.find(f => f.key === featureKey);
                             const plan = {
                                 featureKey,
@@ -1079,13 +1269,19 @@ function startServer({ data: initialData, port, projectRoot }) {
                                 generatedAt: new Date().toISOString(),
                                 updatedAt: new Date().toISOString(),
                                 baseUrl: parsedPlan.baseUrl,
-                                testCases: (parsedPlan.testCases || []).map((tc) => ({ ...tc, status: 'pending' })),
+                                testCases: parsedPlan.testCases.map((tc) => ({ ...tc, status: 'pending' })),
                             };
                             saveE2ePlan(projectRoot, plan);
                             broadcast('e2e-plan-ready', { featureKey, plan });
                         }
                         catch (err) {
-                            broadcast('e2e-plan-error', { featureKey, message: `Не удалось распарсить план: ${err.message}` });
+                            const blockHint = queueBlockSignal
+                                ? ` Возможная причина: блокировка/лимит агента (${queueBlockSignal}).`
+                                : '';
+                            broadcast('e2e-plan-error', {
+                                featureKey,
+                                message: `Не удалось распарсить план: ${err.message}.${blockHint}`.trim(),
+                            });
                         }
                     }
                     if (task === 'write-e2e-tests' && featureKey) {
@@ -1102,6 +1298,35 @@ function startServer({ data: initialData, port, projectRoot }) {
                     process.stdout.write('   ✅ Agent done, rescanning...\n');
                     try {
                         currentData = await (0, scanner_1.scanProject)(projectRoot);
+                        if (targetSourcePaths.length > 0) {
+                            const srcByPath = new Map(currentData.modules
+                                .filter((m) => m.type !== 'test')
+                                .map((m) => [normalizeRelPath(m.relativePath), m]));
+                            const unresolved = targetSourcePaths.filter((rel) => {
+                                const mod = srcByPath.get(rel);
+                                return !!mod && !mod.hasTests && !mod.isInfra;
+                            });
+                            if (unresolved.length > 0) {
+                                broadcast('agent-output', {
+                                    line: `⚠️ После задачи осталось без тестов: ${unresolved.length}/${targetSourcePaths.length} файлов`,
+                                    isError: true,
+                                });
+                                unresolved.slice(0, 20).forEach((rel) => {
+                                    broadcast('agent-output', { line: `   • ${rel}`, isError: true });
+                                });
+                                if (unresolved.length > 20) {
+                                    broadcast('agent-output', {
+                                        line: `   ... и еще ${unresolved.length - 20} файлов`,
+                                        isError: true,
+                                    });
+                                }
+                            }
+                            else {
+                                broadcast('agent-output', {
+                                    line: `✅ Проверка: все ${targetSourcePaths.length} целевых файлов теперь отмечены как с тестами`,
+                                });
+                            }
+                        }
                         broadcast('data-updated');
                     }
                     catch { }