@minionry/minion 0.7.36

package/dist/server/services/websocket/quality-persistence.js

@@ -0,0 +1,410 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { spacePath } from '../space-layout.js';
+import { gradeFromScore } from './quality-grading.js';
+const MAX_HISTORY_ENTRIES = 100;
+const MAX_REPORT_HISTORY_FILES = 200;
+export const MAX_SUPPRESSIONS = 5000;
+const MERGE_WINDOW_MS = 60_000;
+export function slugify(dirPath) {
+    if (dirPath === '.' || dirPath === './')
+        return '_root';
+    return dirPath.replace(/[/\\]/g, '_').replace(/^_+|_+$/g, '') || '_root';
+}
+function ensureDir(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+function readJson(filePath, fallback) {
+    try {
+        if (existsSync(filePath)) {
+            return JSON.parse(readFileSync(filePath, 'utf-8'));
+        }
+    }
+    catch {
+    }
+    return fallback;
+}
+function writeJson(filePath, data) {
+    try {
+        writeFileSync(filePath, JSON.stringify(data, null, 2));
+    }
+    catch (error) {
+        console.error('[QualityPersistence] Error writing:', filePath, error);
+    }
+}
+function isSuppression(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const entry = value;
+    return ['fingerprint', 'path', 'reason', 'dismissedAt', 'title', 'file'].every((key) => typeof entry[key] === 'string');
+}
+function isAgentCostCacheEntry(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const entry = value;
+    if (typeof entry.mtimeMs !== 'number' || typeof entry.size !== 'number' || !Array.isArray(entry.movements))
+        return false;
+    return entry.movements.every((m) => {
+        if (typeof m !== 'object' || m === null)
+            return false;
+        const movement = m;
+        return (typeof movement.engine === 'string' &&
+            typeof movement.toolUses === 'number' &&
+            Array.isArray(movement.written) &&
+            movement.written.every((path) => typeof path === 'string') &&
+            (movement.outputTokens === undefined || typeof movement.outputTokens === 'number') &&
+            (movement.durationMs === undefined || typeof movement.durationMs === 'number'));
+    });
+}
+function withoutDismissal(findings) {
+    if (!findings?.some((f) => f.dismissal !== undefined))
+        return findings;
+    return findings.map((f) => {
+        if (f.dismissal === undefined)
+            return f;
+        const { dismissal: _stripped, ...rest } = f;
+        return rest;
+    });
+}
+export function isReviewOf(review, report) {
+    if (typeof review.reportTimestamp === 'string')
+        return report.timestamp === review.reportTimestamp;
+    const reportAt = new Date(report.timestamp).getTime();
+    const reviewAt = new Date(review.timestamp).getTime();
+    return Number.isFinite(reportAt) && Number.isFinite(reviewAt) && reportAt < reviewAt;
+}
+export function mergeCodeReview(report, review) {
+    if (!review)
+        return report;
+    if (!isReviewOf(review, report))
+        return { ...report, codeReview: [] };
+    return { ...report, codeReview: review.findings };
+}
+export class QualityPersistence {
+    qualityDir;
+    reportsDir;
+    reportHistoryDir;
+    toolOutputRoot;
+    configPath;
+    historyPath;
+    suppressionsPath;
+    agentCostCachePath;
+    constructor(workingDir) {
+        this.qualityDir = spacePath(workingDir, 'quality');
+        this.reportsDir = join(this.qualityDir, 'reports');
+        this.reportHistoryDir = join(this.reportsDir, 'history');
+        this.toolOutputRoot = join(this.qualityDir, 'tool-output');
+        this.configPath = join(this.qualityDir, 'config.json');
+        this.historyPath = join(this.qualityDir, 'history.json');
+        this.suppressionsPath = join(this.qualityDir, 'suppressions.json');
+        this.agentCostCachePath = join(this.qualityDir, 'agent-cost-cache.json');
+        ensureDir(this.reportsDir);
+        ensureDir(this.reportHistoryDir);
+    }
+    static isSetUp(workingDir) {
+        return existsSync(join(spacePath(workingDir, 'quality'), 'config.json'));
+    }
+    toolOutputDir(dirPath) {
+        const dir = join(this.toolOutputRoot, slugify(dirPath));
+        ensureDir(dir);
+        return dir;
+    }
+    loadConfig() {
+        const config = readJson(this.configPath, { directories: [] });
+        return config.directories;
+    }
+    saveConfig(directories) {
+        writeJson(this.configPath, { directories });
+    }
+    addDirectory(path, label) {
+        const dirs = this.loadConfig();
+        if (!dirs.some((d) => d.path === path)) {
+            dirs.push({ path, label });
+            this.saveConfig(dirs);
+        }
+    }
+    removeDirectory(path) {
+        const dirs = this.loadConfig().filter((d) => d.path !== path);
+        this.saveConfig(dirs);
+    }
+    loadReport(dirPath) {
+        const slug = slugify(dirPath);
+        const reportPath = join(this.reportsDir, `${slug}.json`);
+        return readJson(reportPath, null);
+    }
+    saveReport(dirPath, results) {
+        const slug = slugify(dirPath);
+        const reportPath = join(this.reportsDir, `${slug}.json`);
+        const findings = withoutDismissal(results.findings);
+        const codeReview = withoutDismissal(results.codeReview);
+        writeJson(reportPath, findings === results.findings && codeReview === results.codeReview ? results : { ...results, findings, codeReview });
+    }
+    archiveReport(dirPath) {
+        const slug = slugify(dirPath);
+        const reportPath = join(this.reportsDir, `${slug}.json`);
+        if (!existsSync(reportPath))
+            return;
+        const archivePath = join(this.reportHistoryDir, `${Date.now()}_${slug}.json`);
+        try {
+            copyFileSync(reportPath, archivePath);
+        }
+        catch (error) {
+            console.error('[QualityPersistence] Error archiving:', archivePath, error);
+            return;
+        }
+        this.pruneReportHistory();
+    }
+    loadAllReports(directories) {
+        const reports = {};
+        for (const dir of directories) {
+            const report = this.loadReport(dir.path);
+            if (report) {
+                reports[dir.path] = report;
+            }
+        }
+        return reports;
+    }
+    pruneReportHistory() {
+        try {
+            const files = readdirSync(this.reportHistoryDir).filter((f) => f.endsWith('.json')).sort();
+            if (files.length <= MAX_REPORT_HISTORY_FILES)
+                return;
+            const toRemove = files.slice(0, files.length - MAX_REPORT_HISTORY_FILES);
+            for (const file of toRemove) {
+                try {
+                    unlinkSync(join(this.reportHistoryDir, file));
+                }
+                catch {   }
+            }
+        }
+        catch {   }
+    }
+    loadHistory() {
+        const history = readJson(this.historyPath, { entries: [] });
+        return history.entries;
+    }
+    appendHistory(results, dirPath) {
+        const history = this.loadHistory();
+        const now = new Date();
+        const lastEntry = history[history.length - 1];
+        const lastTime = lastEntry ? new Date(lastEntry.timestamp).getTime() : 0;
+        if (lastEntry && now.getTime() - lastTime < MERGE_WINDOW_MS) {
+            mergeIntoHistoryEntry(lastEntry, results, dirPath, now);
+        }
+        else {
+            history.push(newHistoryEntry(results, dirPath, now));
+        }
+        this.writeHistory(history);
+    }
+    updateHistoryEntry(results, dirPath) {
+        const history = this.loadHistory();
+        const now = new Date();
+        let index = history.length - 1;
+        while (index >= 0 && !history[index].directories.some((d) => d.path === dirPath))
+            index -= 1;
+        if (index >= 0) {
+            mergeIntoHistoryEntry(history[index], results, dirPath, now);
+        }
+        else {
+            history.push(newHistoryEntry(results, dirPath, now));
+        }
+        this.writeHistory(history);
+    }
+    writeHistory(history) {
+        while (history.length > MAX_HISTORY_ENTRIES) {
+            history.shift();
+        }
+        writeJson(this.historyPath, { entries: history });
+    }
+    loadCodeReview(dirPath) {
+        const slug = slugify(dirPath);
+        const reviewPath = join(this.reportsDir, `${slug}-review.json`);
+        return readJson(reviewPath, null);
+    }
+    saveCodeReview(dirPath, findings, summary, reportTimestamp) {
+        const slug = slugify(dirPath);
+        const reviewPath = join(this.reportsDir, `${slug}-review.json`);
+        const fingerprints = findings.flatMap((f) => (typeof f.fingerprint === 'string' ? [f.fingerprint] : []));
+        const data = {
+            findings: withoutDismissal(findings) ?? findings,
+            summary,
+            timestamp: new Date().toISOString(),
+            fingerprints,
+            ...(reportTimestamp === undefined ? {} : { reportTimestamp }),
+        };
+        writeJson(reviewPath, data);
+        const ts = Date.now();
+        const archivePath = join(this.reportHistoryDir, `${ts}_${slug}-review.json`);
+        writeJson(archivePath, data);
+        this.pruneReportHistory();
+    }
+    loadBaseline(dirPath) {
+        const report = this.loadReport(dirPath);
+        if (!report || !Array.isArray(report.fingerprints) || typeof report.timestamp !== 'string')
+            return null;
+        const fingerprints = new Set(report.fingerprints);
+        const review = this.loadCodeReview(dirPath);
+        for (const fingerprint of review?.fingerprints ?? [])
+            fingerprints.add(fingerprint);
+        return { timestamp: report.timestamp, fingerprints };
+    }
+    loadSuppressions() {
+        const file = readJson(this.suppressionsPath, null);
+        const entries = file && typeof file === 'object' && Array.isArray(file.entries) ? file.entries : [];
+        return entries.filter(isSuppression);
+    }
+    loadSuppressionsFor(dirPath) {
+        return this.loadSuppressions().filter((entry) => entry.path === dirPath);
+    }
+    saveSuppressions(entries) {
+        const ordered = [...entries].sort((a, b) => (a.dismissedAt < b.dismissedAt ? -1 : a.dismissedAt > b.dismissedAt ? 1 : 0));
+        const dropped = Math.max(0, ordered.length - MAX_SUPPRESSIONS);
+        writeJson(this.suppressionsPath, { entries: ordered.slice(dropped) });
+        return { dropped };
+    }
+    loadAgentCostCache() {
+        const file = readJson(this.agentCostCachePath, null);
+        if (!file || typeof file !== 'object' || file.version !== 1 || typeof file.files !== 'object' || file.files === null)
+            return {};
+        const entries = {};
+        for (const [name, entry] of Object.entries(file.files)) {
+            if (isAgentCostCacheEntry(entry))
+                entries[name] = entry;
+        }
+        return entries;
+    }
+    saveAgentCostCache(files) {
+        const data = { version: 1, files };
+        writeJson(this.agentCostCachePath, data);
+    }
+    get activeOpsPath() {
+        return join(this.qualityDir, 'active-ops.json');
+    }
+    get pendingResultsPath() {
+        return join(this.qualityDir, 'pending-results.json');
+    }
+    setActiveOperation(path, type, meta) {
+        const ops = this.loadActiveOperations();
+        const existing = ops.findIndex((o) => o.path === path);
+        const entry = {
+            type,
+            path,
+            startedAt: new Date().toISOString(),
+            ...(meta?.sessionId ? { sessionId: meta.sessionId } : {}),
+        };
+        if (existing >= 0) {
+            ops[existing] = entry;
+        }
+        else {
+            ops.push(entry);
+        }
+        writeJson(this.activeOpsPath, ops);
+    }
+    clearActiveOperation(path) {
+        const ops = this.loadActiveOperations().filter((o) => o.path !== path);
+        writeJson(this.activeOpsPath, ops);
+    }
+    loadActiveOperations() {
+        return readJson(this.activeOpsPath, []);
+    }
+    addPendingResult(result) {
+        const pending = this.loadPendingResults();
+        const filtered = pending.filter((p) => !(p.path === result.path && p.type === result.type));
+        filtered.push(result);
+        writeJson(this.pendingResultsPath, filtered);
+    }
+    loadPendingResults() {
+        return readJson(this.pendingResultsPath, []);
+    }
+    clearPendingResults(path) {
+        if (!path) {
+            writeJson(this.pendingResultsPath, []);
+            return;
+        }
+        const filtered = this.loadPendingResults().filter((p) => p.path !== path);
+        writeJson(this.pendingResultsPath, filtered);
+    }
+    loadState() {
+        const directories = this.loadConfig();
+        const reports = this.loadAllReports(directories);
+        const history = this.loadHistory();
+        for (const dir of directories) {
+            if (reports[dir.path]) {
+                reports[dir.path] = mergeCodeReview(reports[dir.path], this.loadCodeReview(dir.path));
+            }
+        }
+        const activeOperations = this.loadActiveOperations();
+        const pendingResults = this.loadPendingResults();
+        return { directories, reports, history, activeOperations, pendingResults };
+    }
+}
+function historyDirectoryEntry(results, dirPath) {
+    return { path: dirPath, score: results.overall, grade: results.grade };
+}
+function extractCategoryScores(results) {
+    return results.scoreBreakdown
+        ? results.scoreBreakdown.categoryPenalties.map((cp) => ({
+            category: cp.category,
+            score: cp.score,
+            grade: cp.grade,
+        }))
+        : undefined;
+}
+function newHistoryEntry(results, dirPath, now) {
+    return {
+        timestamp: now.toISOString(),
+        overall: results.overall,
+        grade: results.grade,
+        issueDensity: results.scoreBreakdown?.issueDensity,
+        categoryScores: extractCategoryScores(results),
+        dimensionScores: extractDimensionScores(results),
+        directories: [historyDirectoryEntry(results, dirPath)],
+        scanDurationMs: results.scanDurationMs,
+        reviewDurationMs: results.reviewDurationMs,
+        ...(results.commit ? { commit: results.commit } : {}),
+    };
+}
+function mergeIntoHistoryEntry(entry, results, dirPath, now) {
+    entry.directories = [...entry.directories.filter((d) => d.path !== dirPath), historyDirectoryEntry(results, dirPath)];
+    const totalScore = entry.directories.reduce((sum, d) => sum + d.score, 0);
+    entry.overall = Math.round(totalScore / entry.directories.length);
+    const allNA = entry.directories.every((d) => d.grade === 'N/A');
+    entry.grade = allNA ? 'N/A' : gradeFromScore(entry.overall);
+    entry.timestamp = now.toISOString();
+    const categoryScores = extractCategoryScores(results);
+    const issueDensity = results.scoreBreakdown?.issueDensity;
+    const dimensionScores = extractDimensionScores(results);
+    if (categoryScores)
+        entry.categoryScores = categoryScores;
+    if (issueDensity !== undefined)
+        entry.issueDensity = issueDensity;
+    if (dimensionScores)
+        entry.dimensionScores = dimensionScores;
+    if (typeof results.scanDurationMs === 'number')
+        entry.scanDurationMs = results.scanDurationMs;
+    if (typeof results.reviewDurationMs === 'number')
+        entry.reviewDurationMs = results.reviewDurationMs;
+    if (results.commit)
+        entry.commit = results.commit;
+    else
+        delete entry.commit;
+}
+function extractDimensionScores(results) {
+    if (!results.dimensions)
+        return undefined;
+    const byName = new Map(results.dimensions.map((d) => [d.name, d]));
+    const sec = byName.get('security');
+    const rel = byName.get('reliability');
+    const maint = byName.get('maintainability');
+    if (!sec || !rel || !maint)
+        return undefined;
+    return {
+        security: { score: sec.score, grade: sec.grade },
+        reliability: { score: rel.score, grade: rel.grade },
+        maintainability: { score: maint.score, grade: maint.grade },
+    };
+}