viberadar 0.3.223 → 0.3.225

package/README.md

@@ -56,16 +56,22 @@ npx jest --coverage
 npx playwright test
 ```
 
-## Logging standard
-
-Repository includes an observability baseline for structured logs:
-
-- Standard document: `docs/observability/logging-standard.md`
-- Error code dictionary: `config/logging-error-codes.json`
-- CI/lint command: `npm run lint:logs`
-- Lint self-check tests: `npm run test:lint-logs`
-
-## Tech
+## Logging standard
+
+Repository includes an observability baseline for structured logs:
+
+- Standard document: `docs/observability/logging-standard.md`
+- Error code dictionary: `config/logging-error-codes.json`
+- CI/lint command: `npm run lint:logs`
+- Lint self-check tests: `npm run test:lint-logs`
+
+## Task tracker standard
+
+Task Tracker imports project tasks from `viberadar.tasks.json`.
+Authoring rules for human reviewers and Codex skills are documented in
+`docs/task-tracker/task-authoring-standard.md`.
+
+## Tech
 
 - CLI: TypeScript + Node.js
 - Dashboard: vanilla HTML/JS (zero dependencies in browser)

package/dist/server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAO7B,OAAO,EAAE,UAAU,EAA4H,MAAM,YAAY,CAAC;AAkBlK,UAAU,aAAa;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;CACrB;AA0vED,wBAAgB,WAAW,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAqgH1G"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAO7B,OAAO,EAAE,UAAU,EAA4H,MAAM,YAAY,CAAC;AAiBlK,UAAU,aAAa;IACrB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;CACrB;AA0vED,wBAAgB,WAAW,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAgsH1G"}

package/dist/server/index.js

@@ -2336,7 +2336,132 @@ function startServer({ data: initialData, port, projectRoot }) {
             }
             return { passes, fails };
         }
-        function normalizeK6Summary(raw, exitCode) {
+        function parseK6ThresholdMs(thresholds, percentile) {
+            if (!thresholds || typeof thresholds !== 'object')
+                return undefined;
+            for (const expression of Object.keys(thresholds)) {
+                const escaped = percentile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const match = expression.match(new RegExp(`p\\(${escaped}\\)\\s*<\\s*(\\d+(?:\\.\\d+)?)`));
+                if (match) {
+                    const value = Number(match[1]);
+                    if (Number.isFinite(value))
+                        return value;
+                }
+            }
+            return undefined;
+        }
+        function normalizeK6EndpointTag(tags) {
+            if (!tags || typeof tags !== 'object')
+                return null;
+            const record = tags;
+            const candidates = [record.endpoint, record.name, record.url];
+            for (const candidate of candidates) {
+                if (typeof candidate !== 'string')
+                    continue;
+                const value = candidate.trim();
+                if (!value)
+                    continue;
+                return value.replace(/^https?:\/\/[^/]+/i, '').slice(0, 180);
+            }
+            return null;
+        }
+        function percentile(values, p) {
+            if (values.length === 0)
+                return undefined;
+            const sorted = values.slice().sort((a, b) => a - b);
+            const rank = (sorted.length - 1) * p;
+            const lower = Math.floor(rank);
+            const upper = Math.ceil(rank);
+            if (lower === upper)
+                return sorted[lower];
+            const weight = rank - lower;
+            return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+        }
+        function parseK6EndpointMetrics(metricsPath) {
+            if (!fs.existsSync(metricsPath))
+                return [];
+            const acc = new Map();
+            const getBucket = (endpoint) => {
+                let bucket = acc.get(endpoint);
+                if (!bucket) {
+                    bucket = { requests: 0, failures: 0, durations: [], durationSum: 0 };
+                    acc.set(endpoint, bucket);
+                }
+                return bucket;
+            };
+            const fd = fs.openSync(metricsPath, 'r');
+            const buffer = Buffer.alloc(1024 * 1024);
+            let remainder = '';
+            try {
+                while (true) {
+                    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+                    if (bytesRead <= 0)
+                        break;
+                    const text = remainder + buffer.subarray(0, bytesRead).toString('utf-8');
+                    const lines = text.split(/\r?\n/);
+                    remainder = lines.pop() || '';
+                    for (const line of lines)
+                        processK6MetricLine(line);
+                }
+                if (remainder.trim())
+                    processK6MetricLine(remainder);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            function processK6MetricLine(line) {
+                if (!line.trim())
+                    return;
+                let point;
+                try {
+                    point = JSON.parse(line);
+                }
+                catch {
+                    return;
+                }
+                if (point?.type !== 'Point')
+                    return;
+                const data = point.data;
+                if (!data || typeof data.value !== 'number')
+                    return;
+                const endpoint = normalizeK6EndpointTag(data.tags);
+                if (!endpoint)
+                    return;
+                const bucket = getBucket(endpoint);
+                if (point.metric === 'http_reqs') {
+                    bucket.requests += data.value;
+                }
+                else if (point.metric === 'http_req_failed') {
+                    if (data.value > 0)
+                        bucket.failures += data.value;
+                }
+                else if (point.metric === 'http_req_duration') {
+                    bucket.durations.push(data.value);
+                    bucket.durationSum += data.value;
+                }
+            }
+            return Array.from(acc.entries())
+                .map(([endpoint, bucket]) => {
+                const requests = Math.round(bucket.requests || bucket.durations.length);
+                const failures = Math.round(bucket.failures);
+                const avgDuration = bucket.durations.length > 0 ? bucket.durationSum / bucket.durations.length : undefined;
+                return {
+                    endpoint,
+                    requests,
+                    failures,
+                    errorPct: requests > 0 ? (failures / requests) * 100 : undefined,
+                    avgDuration,
+                    p90Duration: percentile(bucket.durations, 0.90),
+                    p95Duration: percentile(bucket.durations, 0.95),
+                    p99Duration: percentile(bucket.durations, 0.99),
+                    maxDuration: bucket.durations.length ? bucket.durations.reduce((max, value) => Math.max(max, value), 0) : undefined,
+                };
+            })
+                .filter((endpoint) => endpoint.requests > 0 || endpoint.avgDuration != null)
+                .sort((a, b) => (b.p95Duration || 0) - (a.p95Duration || 0) || b.requests - a.requests)
+                .slice(0, 100);
+        }
+        function normalizeK6Summary(raw, exitCode, metricsPath) {
             const metrics = raw?.metrics || {};
             const duration = metrics.http_req_duration?.values || {};
             const reqs = metrics.http_reqs?.values || {};
@@ -2352,6 +2477,9 @@ function startServer({ data: initialData, port, projectRoot }) {
                         thresholdsPassed++;
                 }
             }
+            const endpoints = metricsPath ? parseK6EndpointMetrics(metricsPath) : [];
+            const p95ThresholdMs = parseK6ThresholdMs(metrics.http_req_duration?.thresholds, '95');
+            const p99ThresholdMs = parseK6ThresholdMs(metrics.http_req_duration?.thresholds, '99');
             return {
                 totalRequests: typeof reqs.count === 'number' ? reqs.count : undefined,
                 rps: typeof reqs.rate === 'number' ? reqs.rate : undefined,
@@ -2365,14 +2493,17 @@ function startServer({ data: initialData, port, projectRoot }) {
                 checksFailed: checks.fails,
                 thresholdsPassed,
                 thresholdsFailed,
+                p95ThresholdMs,
+                p99ThresholdMs,
+                endpoints,
                 exitCode,
             };
         }
-        function readK6Summary(summaryPath, exitCode) {
+        function readK6Summary(summaryPath, exitCode, metricsPath) {
             try {
                 if (!fs.existsSync(summaryPath))
                     return { exitCode };
-                return normalizeK6Summary(JSON.parse(fs.readFileSync(summaryPath, 'utf-8')), exitCode);
+                return normalizeK6Summary(JSON.parse(fs.readFileSync(summaryPath, 'utf-8')), exitCode, metricsPath);
             }
             catch {
                 return { exitCode };
@@ -2426,6 +2557,31 @@ function startServer({ data: initialData, port, projectRoot }) {
                 catch { }
             }
         }
+        function enrichLoadRunRecord(record) {
+            if (Array.isArray(record.summary?.endpoints) && record.summary.endpoints.length > 0) {
+                return { record, changed: false };
+            }
+            const resultPath = record.config?.resultPath;
+            if (!resultPath || typeof resultPath !== 'string') {
+                return { record, changed: false };
+            }
+            const summaryPath = path.join(resultPath, 'summary.json');
+            const metricsPath = path.join(resultPath, 'metrics.ndjson');
+            const summary = readK6Summary(summaryPath, record.summary?.exitCode ?? null, metricsPath);
+            if (!summary || !Array.isArray(summary.endpoints) || summary.endpoints.length === 0) {
+                return { record, changed: false };
+            }
+            const next = {
+                ...record,
+                summary: { ...(record.summary || {}), ...summary },
+            };
+            if (summary.totalRequests != null)
+                next.totalRequests = summary.totalRequests;
+            if (summary.errorPct != null && summary.totalRequests != null) {
+                next.totalErrors = Math.round(summary.totalRequests * (summary.errorPct / 100));
+            }
+            return { record: next, changed: true };
+        }
         function loadLastRunIntoState() {
             const latest = readLoadRunIndex()[0];
             if (!latest)
@@ -2757,10 +2913,27 @@ function startServer({ data: initialData, port, projectRoot }) {
         /** Actually spawn the agent process for a queue item */
         async function executeAgentItem(item) {
             const { runId, task, featureKey, filePath, selectedFilePaths, title, agent, savedErrors, savedFailedFiles, savedTestType, autoFixAttempt = 0, autoFixSourceTask, } = item;
+            const trackerTaskId = typeof item.meta?.taskId === 'string' ? item.meta.taskId : null;
             const normalizeRelPath = (p) => p.replace(/\\/g, '/');
             const emitOutput = (line, isError = false, isDim = false) => {
                 broadcast('agent-output', { runId, line, isError, isDim });
             };
+            const updateTrackedTaskFromRun = (phase) => {
+                if (!trackerTaskId)
+                    return;
+                try {
+                    const patch = phase === 'completed'
+                        ? { status: 'done', lastRunId: runId }
+                        : phase === 'failed'
+                            ? { status: 'review', lastRunId: runId }
+                            : { lastRunId: runId };
+                    (0, tracker_1.updateTrackerTask)(projectRoot, trackerTaskId, patch);
+                    broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME, taskId: trackerTaskId, runId, phase });
+                }
+                catch (err) {
+                    emitOutput(`⚠️ Не удалось обновить задачу трекера ${trackerTaskId}: ${err.message || err}`, true, true);
+                }
+            };
             const targetSourcePaths = (() => {
                 if (task === 'write-tests-file' && filePath) {
                     return [normalizeRelPath(filePath)];
@@ -2783,6 +2956,7 @@ function startServer({ data: initialData, port, projectRoot }) {
             });
             function failBeforeStart(message) {
                 setRunPhase(runId, 'failed', { error: message, targetSourcePaths });
+                updateTrackedTaskFromRun('failed');
                 broadcast('agent-error', { runId, message });
                 agentRunning = false;
                 processNextInQueue();
@@ -3480,12 +3654,14 @@ function startServer({ data: initialData, port, projectRoot }) {
                         validationStats: finalValidationStats,
                         error: finalError,
                     });
+                    updateTrackedTaskFromRun(finalPhase);
                     processNextInQueue(true);
                 }
                 else if (code === 255) {
                     process.stdout.write(`   ❌ Agent auth error (exit code 255)\n`);
                     const message = `${agent === 'claude' ? 'Claude Code' : 'Codex'} не авторизован. Нажми 🔑 Перелогиниться в меню агента.`;
                     setRunPhase(runId, 'failed', { targetSourcePaths, error: message });
+                    updateTrackedTaskFromRun('failed');
                     broadcast('agent-error', {
                         runId,
                         message,
@@ -3498,6 +3674,7 @@ function startServer({ data: initialData, port, projectRoot }) {
                     process.stdout.write(`   ❌ Agent failed (exit code ${code})\n`);
                     const message = `Агент завершился с кодом ${code}`;
                     setRunPhase(runId, 'failed', { targetSourcePaths, error: message });
+                    updateTrackedTaskFromRun('failed');
                     broadcast('agent-error', { runId, message });
                     if (queueBlockSignal === 403 || queueBlockSignal === 429) {
                         stopQueuedTasks(`пойман ${queueBlockSignal} от ${agent === 'claude' ? 'Claude Code' : 'Codex'}`);
@@ -3519,6 +3696,7 @@ function startServer({ data: initialData, port, projectRoot }) {
                     : `Не удалось запустить ${agent}: ${err.message}`;
                 process.stdout.write('   ❌ Agent spawn error: ' + err.message + '\n');
                 setRunPhase(runId, 'failed', { targetSourcePaths, error: msg });
+                updateTrackedTaskFromRun('failed');
                 broadcast('agent-error', { runId, message: msg, notInstalled: isNotFound, agent });
                 processNextInQueue(true);
             });
@@ -4001,7 +4179,7 @@ function startServer({ data: initialData, port, projectRoot }) {
                         sendJson(res, 409, { ok: false, error: 'Не удалось поставить задачу в очередь агента' });
                         return;
                     }
-                    const updatedTask = (0, tracker_1.setTrackerTaskRun)(projectRoot, task.id, runId);
+                    const updatedTask = (0, tracker_1.updateTrackerTask)(projectRoot, task.id, { status: 'in-progress', lastRunId: runId });
                     broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME, taskId: task.id, runId });
                     sendJson(res, 200, { ok: true, runId, task: updatedTask });
                 }
@@ -5393,7 +5571,25 @@ a{color:var(--blue)}
                         return;
                     }
                     const runPath = path.join(loadRunsDir, `${runId}.json`);
-                    const record = JSON.parse(fs.readFileSync(runPath, 'utf-8'));
+                    const parsed = JSON.parse(fs.readFileSync(runPath, 'utf-8'));
+                    const { record, changed } = enrichLoadRunRecord(parsed);
+                    if (changed) {
+                        try {
+                            fs.writeFileSync(runPath, JSON.stringify(record, null, 2), 'utf-8');
+                        }
+                        catch { }
+                        try {
+                            const index = readLoadRunIndex();
+                            const item = index.find((i) => i.runId === runId);
+                            if (item) {
+                                item.summary = record.summary;
+                                item.status = record.status;
+                                item.endTime = record.endTime;
+                                writeLoadRunIndex(index);
+                            }
+                        }
+                        catch { }
+                    }
                     res.writeHead(200, jsonH);
                     res.end(JSON.stringify(record));
                 }
@@ -5613,7 +5809,7 @@ a{color:var(--blue)}
                             loadState.status = code === 0 ? 'done' : 'error';
                         }
                         loadState.endTime = Date.now();
-                        loadState.summary = readK6Summary(summaryPath, code);
+                        loadState.summary = readK6Summary(summaryPath, code, jsonOutPath);
                         if (loadState.summary?.totalRequests != null)
                             loadState.totalRequests = loadState.summary.totalRequests;
                         if (loadState.summary?.errorPct != null && loadState.summary.totalRequests != null) {