@minionry/minion 0.7.36

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

@@ -0,0 +1,48 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { join, resolve } from 'node:path';
+import { validatePathWithinWorkingDir } from '../pathUtils.js';
+import { QualityPersistence } from './quality-persistence.js';
+const persistenceCache = new Map();
+export function getPersistence(workingDir) {
+    let persistence = persistenceCache.get(workingDir);
+    if (!persistence) {
+        persistence = new QualityPersistence(workingDir);
+        persistenceCache.set(workingDir, persistence);
+    }
+    return persistence;
+}
+function resolvePath(workingDir, dirPath) {
+    if (!dirPath || dirPath === '.' || dirPath === './')
+        return workingDir;
+    const resolved = dirPath.startsWith('/') ? dirPath : join(workingDir, dirPath);
+    const normalizedResolved = resolve(resolved);
+    const normalizedWorkingDir = resolve(workingDir);
+    if (!normalizedResolved.startsWith(normalizedWorkingDir))
+        return workingDir;
+    return normalizedResolved;
+}
+function resolveAndValidatePath(workingDir, dirPath, isSandboxed) {
+    const resolved = resolvePath(workingDir, dirPath);
+    if (isSandboxed) {
+        const validation = validatePathWithinWorkingDir(resolved, workingDir);
+        if (!validation.valid) {
+            return { resolved: '', error: validation.error || 'Path outside project directory' };
+        }
+        return { resolved: validation.resolvedPath };
+    }
+    return { resolved };
+}
+function escapesWorkingDir(workingDir, dirPath) {
+    if (!dirPath || dirPath === '.' || dirPath === './')
+        return false;
+    const candidate = resolve(dirPath.startsWith('/') ? dirPath : join(workingDir, dirPath));
+    const root = resolve(workingDir);
+    return candidate !== root && !candidate.startsWith(`${root}/`);
+}
+export function resolveQualitySdkPath(workingDir, dirPath) {
+    if (escapesWorkingDir(workingDir, dirPath)) {
+        return { resolved: '', error: `path '${dirPath}' resolves outside the Space working directory` };
+    }
+    return resolveAndValidatePath(workingDir, dirPath, true);
+}

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

@@ -0,0 +1,270 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { dirname, relative } from 'node:path';
+import { collectedContentReader, normalizeFindingPath } from './quality-fingerprint.js';
+import { chunkFileList, filesByExt, runCommand } from './quality-tools.js';
+import { ANALYZER_FINDING_BOUND, biomeDiagToFinding, isBiomeComplexityDiagnostic, isEslintComplexityRule } from './quality-types.js';
+const NODE_LINT_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+const PY_LINT_EXTS = ['.py', '.pyi'];
+function newLintAccumulator() {
+    return { errors: 0, warnings: 0, findings: [], ran: false, notRun: [] };
+}
+function notRun(reason) {
+    return { score: 0, findings: [], available: false, issueCount: 0, reason };
+}
+function failureDetail(result) {
+    const stderr = result.stderr.split('\n').map((l) => l.trim()).find(Boolean);
+    if (stderr)
+        return stderr;
+    return result.stdout.split('\n').map((l) => l.trim()).filter(Boolean).pop() ?? '';
+}
+function exitNote(tool, result) {
+    const detail = failureDetail(result);
+    return `${tool} exited ${result.exitCode}${detail ? `: ${detail}` : ''}`;
+}
+function unparseable(tool, err, result) {
+    const message = err instanceof Error ? err.message : String(err);
+    const detail = result.stderr.split('\n').map((l) => l.trim()).find(Boolean);
+    return `${tool}'s JSON output could not be parsed (${message}; exit ${result.exitCode})${detail ? `: ${detail}` : ''}`;
+}
+function processBiomeDiagnostic(d, acc, contentOf) {
+    if (isBiomeComplexityDiagnostic(d))
+        return;
+    if (d.severity === 'error')
+        acc.errors++;
+    else
+        acc.warnings++;
+    acc.findings.push(biomeDiagToFinding(d, 'linting', contentOf));
+}
+function parseBiomeDiagnostics(stdout, acc, contentOf) {
+    const parsed = JSON.parse(stdout);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        throw new Error('not a Biome reporter object');
+    const diagnostics = parsed.diagnostics;
+    if (diagnostics === undefined)
+        return;
+    if (!Array.isArray(diagnostics))
+        throw new Error('"diagnostics" is not a list');
+    for (const d of diagnostics) {
+        processBiomeDiagnostic(d, acc, contentOf);
+    }
+}
+async function lintWithBiome(dirPath, acc, files, targets) {
+    const contentOf = collectedContentReader(files);
+    for (const chunk of chunkFileList(targets)) {
+        const result = await runCommand('npx', ['@biomejs/biome', 'lint', '--reporter=json', ...chunk], dirPath);
+        if (result.exitCode > 1) {
+            acc.notRun.push(exitNote('Biome', result));
+            return;
+        }
+        try {
+            parseBiomeDiagnostics(result.stdout, acc, contentOf);
+        }
+        catch (err) {
+            acc.parseFailure = unparseable('Biome', err, result);
+            return;
+        }
+        acc.ran = true;
+    }
+}
+function processEslintMessage(msg, filePath, dirPath, acc) {
+    if (isEslintComplexityRule(msg.ruleId))
+        return;
+    if (msg.severity === 2)
+        acc.errors++;
+    else
+        acc.warnings++;
+    acc.findings.push({
+        severity: msg.severity === 2 ? 'high' : 'medium',
+        category: 'lint',
+        file: relative(dirPath, filePath),
+        line: msg.line ?? null,
+        title: msg.ruleId || 'Lint issue',
+        description: msg.message || '',
+    });
+}
+function parseEslintResults(stdout) {
+    const parsed = JSON.parse(stdout);
+    if (!Array.isArray(parsed))
+        throw new Error('not an ESLint results list');
+    return parsed;
+}
+async function lintWithEslint(dirPath, acc, targets) {
+    for (const chunk of chunkFileList(targets)) {
+        const result = await runCommand('npx', ['eslint', '--format=json', ...chunk], dirPath);
+        let results;
+        try {
+            results = parseEslintResults(result.stdout);
+        }
+        catch (err) {
+            acc.parseFailure = unparseable('ESLint', err, result);
+            return;
+        }
+        for (const file of results) {
+            for (const msg of file.messages || []) {
+                processEslintMessage(msg, file.filePath, dirPath, acc);
+            }
+        }
+        acc.ran = true;
+    }
+}
+async function lintNode(dirPath, acc, installed, files) {
+    const hasBiome = !installed || installed.has('biome');
+    const hasEslint = !installed || installed.has('eslint');
+    if (!hasBiome && !hasEslint) {
+        acc.notRun.push('no linter is installed for node — npm install -D @biomejs/biome (or eslint)');
+        return;
+    }
+    const targets = filesByExt(files, NODE_LINT_EXTS);
+    if (targets.length === 0) {
+        acc.notRun.push('no JavaScript or TypeScript files to lint');
+        return;
+    }
+    if (hasBiome) {
+        await lintWithBiome(dirPath, acc, files, targets);
+        if (acc.ran || acc.parseFailure)
+            return;
+    }
+    if (hasEslint) {
+        await lintWithEslint(dirPath, acc, targets);
+    }
+}
+function ruffSeverityAndCategory(code) {
+    const family = code?.match(/^([A-Z]+)(\d)/);
+    if (!family)
+        return { severity: 'medium', category: 'lint' };
+    const [, prefix, firstDigit] = family;
+    if (prefix === 'F' || (prefix === 'E' && firstDigit === '9'))
+        return { severity: 'high', category: 'lint' };
+    if (prefix === 'E' || prefix === 'W')
+        return { severity: 'low', category: 'lint' };
+    if (prefix === 'S')
+        return { severity: 'medium', category: 'security' };
+    return { severity: 'medium', category: 'lint' };
+}
+function processRuffItem(item, dirPath, acc) {
+    const code = item.code;
+    const { severity, category } = ruffSeverityAndCategory(code);
+    if (severity === 'high')
+        acc.errors++;
+    else
+        acc.warnings++;
+    const location = item.location;
+    acc.findings.push({
+        severity,
+        category,
+        file: item.filename ? relative(dirPath, item.filename) : '',
+        line: location?.row ?? null,
+        title: code || 'Lint issue',
+        description: item.message || '',
+    });
+}
+async function lintPython(dirPath, acc, files) {
+    const targets = filesByExt(files, PY_LINT_EXTS);
+    if (targets.length === 0) {
+        acc.notRun.push('no Python files to lint');
+        return;
+    }
+    for (const chunk of chunkFileList(targets)) {
+        const result = await runCommand('ruff', ['check', '--output-format=json', ...chunk], dirPath);
+        if (result.exitCode !== 0 && !result.stdout.trim().startsWith('[')) {
+            acc.notRun.push(exitNote('Ruff', result));
+            return;
+        }
+        let items;
+        try {
+            items = JSON.parse(result.stdout);
+            if (!Array.isArray(items))
+                throw new Error('not a Ruff results list');
+        }
+        catch (err) {
+            acc.parseFailure = unparseable('Ruff', err, result);
+            return;
+        }
+        for (const item of items)
+            processRuffItem(item, dirPath, acc);
+        acc.ran = true;
+    }
+}
+export async function cargoWorkspaceRoot(dirPath) {
+    const result = await runCommand('cargo', ['locate-project', '--workspace', '--message-format', 'plain'], dirPath);
+    const manifest = result.stdout.trim();
+    return result.exitCode === 0 && manifest ? dirname(manifest) : dirPath;
+}
+function processClippyMessage(msg, acc, dirPath, cargoRoot) {
+    if (msg.reason !== 'compiler-message' || !msg.message)
+        return;
+    const message = msg.message;
+    const level = message.level;
+    if (level === 'error')
+        acc.errors++;
+    else if (level === 'warning')
+        acc.warnings++;
+    const spans = message.spans;
+    const span = spans?.[0];
+    const code = message.code;
+    const fileName = span?.file_name || '';
+    acc.findings.push({
+        severity: level === 'error' ? 'high' : 'medium',
+        category: 'lint',
+        file: fileName ? normalizeFindingPath(fileName, dirPath, cargoRoot) : '',
+        line: span?.line_start ?? null,
+        title: code?.code || 'Clippy',
+        description: message.message || '',
+    });
+}
+async function lintRust(dirPath, acc, cargoRoot) {
+    const result = await runCommand('cargo', ['clippy', '--message-format=json', '--', '-W', 'clippy::all'], dirPath);
+    if (result.exitCode > 1) {
+        acc.notRun.push(exitNote('clippy', result));
+        return;
+    }
+    acc.ran = true;
+    for (const line of result.stdout.split('\n')) {
+        try {
+            const msg = JSON.parse(line);
+            processClippyMessage(msg, acc, dirPath, cargoRoot);
+        }
+        catch {   }
+    }
+}
+function computeLintScore(totalErrors, totalWarnings, totalLines) {
+    const kloc = Math.max(totalLines / 1000, 1);
+    const penaltyRaw = totalErrors * 10 + totalWarnings * 3;
+    const penaltyPerKloc = penaltyRaw / kloc;
+    let score;
+    if (penaltyPerKloc === 0)
+        score = 100;
+    else if (penaltyPerKloc <= 5)
+        score = 100 - penaltyPerKloc * 2;
+    else if (penaltyPerKloc <= 20)
+        score = 90 - (penaltyPerKloc - 5) * 2;
+    else if (penaltyPerKloc <= 50)
+        score = 60 - (penaltyPerKloc - 20) * 1.5;
+    else
+        score = Math.max(0, 15 - (penaltyPerKloc - 50) * 0.3);
+    return Math.round(Math.max(0, Math.min(100, score)));
+}
+export async function analyzeLinting(dirPath, ecosystems, files, installedToolNames, cargoRoot = dirPath) {
+    const acc = newLintAccumulator();
+    const installed = installedToolNames ? new Set(installedToolNames) : null;
+    if (ecosystems.includes('node'))
+        await lintNode(dirPath, acc, installed, files);
+    if (ecosystems.includes('python') && !acc.parseFailure)
+        await lintPython(dirPath, acc, files);
+    if (ecosystems.includes('rust') && !acc.parseFailure)
+        await lintRust(dirPath, acc, cargoRoot);
+    if (acc.parseFailure)
+        return notRun(acc.parseFailure);
+    if (!acc.ran) {
+        return notRun(acc.notRun.length > 0 ? acc.notRun.join('; ') : `no linter ran — none is rostered for ${ecosystems.join(', ')}`);
+    }
+    const totalLines = files.reduce((sum, f) => sum + f.lines, 0);
+    const score = computeLintScore(acc.errors, acc.warnings, totalLines);
+    return {
+        score,
+        findings: acc.findings.slice(0, ANALYZER_FINDING_BOUND),
+        available: true,
+        issueCount: acc.findings.length,
+    };
+}

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

@@ -0,0 +1,54 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export class OperationRegistry {
+    ops = new Map();
+    key(workingDir, path) {
+        return `${workingDir}::${path}`;
+    }
+    start(workingDir, path, kind) {
+        const k = this.key(workingDir, path);
+        if (this.ops.has(k)) {
+            throw new Error(`Operation already in flight: ${kind} ${path}`);
+        }
+        const controller = new AbortController();
+        this.ops.set(k, { controller, kind, startedAt: Date.now(), waiters: [] });
+        return controller;
+    }
+    setKind(workingDir, path, kind) {
+        const op = this.ops.get(this.key(workingDir, path));
+        if (!op)
+            return false;
+        op.kind = kind;
+        return true;
+    }
+    cancel(workingDir, path) {
+        const k = this.key(workingDir, path);
+        const op = this.ops.get(k);
+        if (!op)
+            return false;
+        op.controller.abort();
+        return true;
+    }
+    finish(workingDir, path) {
+        const k = this.key(workingDir, path);
+        const op = this.ops.get(k);
+        this.ops.delete(k);
+        if (!op)
+            return;
+        for (const waiter of op.waiters.splice(0))
+            waiter();
+    }
+    whenFinished(workingDir, path) {
+        const op = this.ops.get(this.key(workingDir, path));
+        if (!op)
+            return Promise.resolve();
+        return new Promise((resolve) => op.waiters.push(resolve));
+    }
+    has(workingDir, path) {
+        return this.ops.has(this.key(workingDir, path));
+    }
+    getKind(workingDir, path) {
+        return this.ops.get(this.key(workingDir, path))?.kind ?? null;
+    }
+}
+export const operationRegistry = new OperationRegistry();