viberadar 0.3.222 → 0.3.224

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;AAOlK,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,CAk4G1G"}
+{"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,CAypH1G"}

package/dist/server/index.js

@@ -49,6 +49,7 @@ const docx_1 = require("../docx");
 const config_1 = require("../probe/config");
 const runner_1 = require("../probe/runner");
 const notify_1 = require("../probe/notify");
+const tracker_1 = require("../tracker");
 const DASHBOARD_HTML = fs.readFileSync(path.join(__dirname, '../ui/dashboard.html'), 'utf-8');
 // ─── Agent CLI commands ───────────────────────────────────────────────────────
 const WIN = process.platform === 'win32';
@@ -2335,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 || {};
@@ -2351,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,
@@ -2364,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 };
@@ -2437,6 +2569,44 @@ function startServer({ data: initialData, port, projectRoot }) {
             catch { }
         }
         loadLastRunIntoState();
+        function sendJson(res, statusCode, payload) {
+            res.writeHead(statusCode, jsonH);
+            res.end(JSON.stringify(payload));
+        }
+        function readJsonBody(req, maxBytes = 1024 * 1024) {
+            return new Promise((resolve, reject) => {
+                let body = '';
+                req.on('data', (chunk) => {
+                    body += chunk.toString('utf-8');
+                    if (Buffer.byteLength(body, 'utf-8') > maxBytes) {
+                        reject(new Error('Request body is too large'));
+                        req.destroy();
+                    }
+                });
+                req.on('end', () => {
+                    if (!body.trim()) {
+                        resolve({});
+                        return;
+                    }
+                    try {
+                        resolve(JSON.parse(body));
+                    }
+                    catch (err) {
+                        reject(new tracker_1.TrackerValidationError([{ field: 'body', message: err.message || 'invalid JSON' }]));
+                    }
+                });
+                req.on('error', reject);
+            });
+        }
+        function sendTrackerError(res, err) {
+            if (err instanceof tracker_1.TrackerValidationError) {
+                const notFound = err.issues.some((issue) => issue.field === 'id' && issue.message.includes('не найдена'));
+                sendJson(res, notFound ? 404 : 400, { ok: false, error: err.message, issues: err.issues });
+                return;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            sendJson(res, 500, { ok: false, error: message });
+        }
         // ── SSE clients ────────────────────────────────────────────────────────────
         const sseClients = new Set();
         function broadcast(event, payload = {}) {
@@ -2718,10 +2888,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)];
@@ -2744,6 +2931,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();
@@ -3441,12 +3629,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,
@@ -3459,6 +3649,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'}`);
@@ -3480,6 +3671,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);
             });
@@ -3639,6 +3831,9 @@ function startServer({ data: initialData, port, projectRoot }) {
                 }
                 title = `${agentLabel} — пайплайны для "${feat.label}"`;
             }
+            else if (task === 'custom-prompt') {
+                title = `${agentLabel} — ${meta?.title || 'задача трекера'}`;
+            }
             else if (task === 'classify-orphan-tests') {
                 const orphanCount = getOrphanTests(currentData.modules).noFeature.length;
                 if (orphanCount === 0) {
@@ -3730,6 +3925,14 @@ function startServer({ data: initialData, port, projectRoot }) {
             .on('add', f => scheduleRescan(path.join(projectRoot, f)))
             .on('change', f => scheduleRescan(path.join(projectRoot, f)))
             .on('unlink', f => scheduleRescan(path.join(projectRoot, f)));
+        chokidar_1.default.watch([tracker_1.TRACKER_FILE_NAME], {
+            cwd: projectRoot,
+            ignoreInitial: true,
+            persistent: true,
+        })
+            .on('add', () => broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME }))
+            .on('change', () => broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME }))
+            .on('unlink', () => broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME, deleted: true }));
         // ── HTTP server ────────────────────────────────────────────────────────────
         const server = http.createServer((req, res) => {
             const rawUrl = req.url ?? '/';
@@ -3906,6 +4109,83 @@ function startServer({ data: initialData, port, projectRoot }) {
                 res.end(JSON.stringify(buildAgentStateSnapshot()));
                 return;
             }
+            if (url === '/api/tasks' && req.method === 'GET') {
+                try {
+                    sendJson(res, 200, { ...(0, tracker_1.readTrackerFile)(projectRoot), filePath: tracker_1.TRACKER_FILE_NAME });
+                }
+                catch (err) {
+                    sendTrackerError(res, err);
+                }
+                return;
+            }
+            if (url === '/api/tasks' && req.method === 'POST') {
+                readJsonBody(req).then((payload) => {
+                    const task = (0, tracker_1.createTrackerTask)(projectRoot, payload?.task ?? payload);
+                    broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME, taskId: task.id });
+                    sendJson(res, 201, { ok: true, task, file: (0, tracker_1.readTrackerFile)(projectRoot) });
+                }).catch((err) => sendTrackerError(res, err));
+                return;
+            }
+            if (url === '/api/tasks/import' && req.method === 'POST') {
+                readJsonBody(req, 2 * 1024 * 1024).then((payload) => {
+                    const result = (0, tracker_1.importTrackerTasks)(projectRoot, payload);
+                    broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME, imported: result.imported });
+                    sendJson(res, 200, { ok: true, imported: result.imported, file: result.file });
+                }).catch((err) => sendTrackerError(res, err));
+                return;
+            }
+            const taskRunMatch = url.match(/^\/api\/tasks\/([^/]+)\/run$/);
+            if (taskRunMatch && req.method === 'POST') {
+                const taskId = decodeURIComponent(taskRunMatch[1]);
+                try {
+                    const file = (0, tracker_1.readTrackerFile)(projectRoot);
+                    const task = file.tasks.find((item) => item.id === taskId);
+                    if (!task) {
+                        sendJson(res, 404, { ok: false, error: `Задача не найдена: ${taskId}` });
+                        return;
+                    }
+                    const prompt = (0, tracker_1.buildTrackerTaskPrompt)(task);
+                    const runId = runAgent('custom-prompt', undefined, undefined, undefined, {
+                        prompt,
+                        title: `задача "${task.title}"`,
+                        taskId: task.id,
+                    });
+                    if (!runId) {
+                        sendJson(res, 409, { ok: false, error: 'Не удалось поставить задачу в очередь агента' });
+                        return;
+                    }
+                    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 });
+                }
+                catch (err) {
+                    sendTrackerError(res, err);
+                }
+                return;
+            }
+            const taskArchiveMatch = url.match(/^\/api\/tasks\/([^/]+)\/archive$/);
+            if (taskArchiveMatch && req.method === 'POST') {
+                const taskId = decodeURIComponent(taskArchiveMatch[1]);
+                try {
+                    const task = (0, tracker_1.archiveTrackerTask)(projectRoot, taskId);
+                    broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME, taskId });
+                    sendJson(res, 200, { ok: true, task });
+                }
+                catch (err) {
+                    sendTrackerError(res, err);
+                }
+                return;
+            }
+            const taskPatchMatch = url.match(/^\/api\/tasks\/([^/]+)$/);
+            if (taskPatchMatch && req.method === 'PATCH') {
+                const taskId = decodeURIComponent(taskPatchMatch[1]);
+                readJsonBody(req).then((payload) => {
+                    const task = (0, tracker_1.updateTrackerTask)(projectRoot, taskId, payload);
+                    broadcast('tasks-updated', { filePath: tracker_1.TRACKER_FILE_NAME, taskId });
+                    sendJson(res, 200, { ok: true, task, file: (0, tracker_1.readTrackerFile)(projectRoot) });
+                }).catch((err) => sendTrackerError(res, err));
+                return;
+            }
             const queueCancelMatch = url.match(/^\/api\/queue\/([^/]+)\/cancel$/);
             if (queueCancelMatch && req.method === 'POST') {
                 const runId = decodeURIComponent(queueCancelMatch[1]);
@@ -5486,7 +5766,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) {