@minionry/minion 0.7.36

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

@@ -0,0 +1,383 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { ADDITIONAL_EXCLUDES, ECOSYSTEM_TOOLS, SOURCE_EXTENSIONS } from './quality-types.js';
+export const FALLBACK_IGNORE_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', '__pycache__',
+    'target', 'vendor', '.venv', 'venv', '.tox', 'coverage',
+    '.minionry', '.cache', '.turbo', '.output',
+]);
+export function detectEcosystem(dirPath) {
+    const ecosystems = [];
+    try {
+        const files = readdirSync(dirPath);
+        if (files.includes('package.json'))
+            ecosystems.push('node');
+        if (files.includes('pyproject.toml') || files.includes('setup.py') || files.includes('requirements.txt'))
+            ecosystems.push('python');
+        if (files.includes('Cargo.toml'))
+            ecosystems.push('rust');
+        if (files.includes('go.mod'))
+            ecosystems.push('go');
+        if (files.includes('Package.swift') || files.some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace')))
+            ecosystems.push('swift');
+        if (files.includes('build.gradle') || files.includes('build.gradle.kts'))
+            ecosystems.push('kotlin');
+    }
+    catch {
+    }
+    if (ecosystems.length === 0)
+        ecosystems.push('unknown');
+    return ecosystems;
+}
+function detectNodePackageManager(dirPath) {
+    try {
+        const files = readdirSync(dirPath);
+        if (files.includes('bun.lockb') || files.includes('bun.lock'))
+            return 'bun';
+        if (files.includes('pnpm-lock.yaml'))
+            return 'pnpm';
+        if (files.includes('yarn.lock'))
+            return 'yarn';
+    }
+    catch {
+    }
+    return 'npm';
+}
+function nodeInstallCmd(pm, pkg) {
+    switch (pm) {
+        case 'yarn': return `yarn add -D ${pkg}`;
+        case 'pnpm': return `pnpm add -D ${pkg}`;
+        case 'bun': return `bun add -d ${pkg}`;
+        default: return `npm install -D ${pkg}`;
+    }
+}
+async function checkToolInstalled(check, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn(check[0], check.slice(1), {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 10000,
+        });
+        proc.on('close', (code) => resolve(code === 0));
+        proc.on('error', () => resolve(false));
+    });
+}
+export async function detectTools(dirPath) {
+    const ecosystems = detectEcosystem(dirPath);
+    const tools = [];
+    const nodePm = ecosystems.includes('node') ? detectNodePackageManager(dirPath) : 'npm';
+    for (const eco of ecosystems) {
+        const specs = ECOSYSTEM_TOOLS[eco] || [];
+        for (const spec of specs) {
+            const installed = await checkToolInstalled(spec.check, dirPath);
+            const installCommand = eco === 'node'
+                ? nodeInstallCmd(nodePm, spec.installCmd.replace(/^npm install -D /, ''))
+                : spec.installCmd;
+            tools.push({
+                name: spec.name,
+                installed,
+                installCommand,
+                category: spec.category,
+            });
+        }
+    }
+    return { tools, ecosystem: ecosystems };
+}
+async function tryInstallCommands(tool, dirPath) {
+    if (tool.installCommand.startsWith('('))
+        return null;
+    const commands = tool.installCommand.split(' || ');
+    let lastStderr = '';
+    for (const cmd of commands) {
+        const parts = cmd.trim().split(' ');
+        const result = await runCommand(parts[0], parts.slice(1), dirPath, { NODE_ENV: 'development' });
+        if (result.exitCode === 0)
+            return null;
+        lastStderr = result.stderr;
+    }
+    const detail = lastStderr ? ` (${lastStderr.trim().split('\n').pop()})` : '';
+    return `${tool.name}: install failed${detail}`;
+}
+export async function installTools(dirPath, toolNames) {
+    const { tools } = await detectTools(dirPath);
+    const toInstall = tools.filter((t) => !t.installed && (!toolNames || toolNames.includes(t.name)));
+    const failures = [];
+    for (const tool of toInstall) {
+        const failure = await tryInstallCommands(tool, dirPath);
+        if (failure)
+            failures.push(failure);
+    }
+    const detected = await detectTools(dirPath);
+    const requestedNames = new Set(toolNames ?? toInstall.map((t) => t.name));
+    const stillMissing = detected.tools.filter((t) => !t.installed && requestedNames.has(t.name)).map((t) => t.name);
+    if (stillMissing.length > 0) {
+        const detail = failures.length > 0 ? ` ${failures.join('; ')}` : '';
+        throw new Error(`Failed to install: ${stillMissing.join(', ')}.${detail}`);
+    }
+    return detected;
+}
+function tryStatSync(path) {
+    try {
+        return statSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+function tryReadFile(path) {
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function tryReaddirSync(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return null;
+    }
+}
+function tryReadSourceFile(fullPath, rootPath) {
+    const content = tryReadFile(fullPath);
+    if (!content)
+        return null;
+    return {
+        path: fullPath,
+        relativePath: relative(rootPath, fullPath),
+        lines: content.split('\n').length,
+        content,
+    };
+}
+function processEntry(entry, dir, rootPath, stack, files) {
+    if (FALLBACK_IGNORE_DIRS.has(entry))
+        return;
+    const fullPath = join(dir, entry);
+    const stat = tryStatSync(fullPath);
+    if (!stat)
+        return;
+    if (stat.isDirectory()) {
+        stack.push(fullPath);
+        return;
+    }
+    if (!stat.isFile() || !SOURCE_EXTENSIONS.has(extname(entry).toLowerCase()))
+        return;
+    const sourceFile = tryReadSourceFile(fullPath, rootPath);
+    if (sourceFile)
+        files.push(sourceFile);
+}
+function collectSourceFilesFallback(dirPath, rootPath) {
+    const files = [];
+    const stack = [dirPath];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        const entries = tryReaddirSync(dir);
+        if (!entries)
+            continue;
+        for (const entry of entries) {
+            processEntry(entry, dir, rootPath, stack, files);
+        }
+    }
+    return files;
+}
+export async function collectSourceFiles(dirPath, rootPath) {
+    const gitCheck = await runCommand('git', ['rev-parse', '--is-inside-work-tree'], dirPath);
+    if (gitCheck.exitCode !== 0) {
+        return collectSourceFilesFallback(dirPath, rootPath);
+    }
+    const result = await runCommand('git', ['ls-files', '--cached', '--others', '--exclude-standard'], dirPath);
+    if (result.exitCode !== 0) {
+        return collectSourceFilesFallback(dirPath, rootPath);
+    }
+    const files = [];
+    const relativePaths = result.stdout.split('\n').filter(Boolean);
+    for (const relPath of relativePaths) {
+        const ext = extname(relPath).toLowerCase();
+        if (!SOURCE_EXTENSIONS.has(ext))
+            continue;
+        const fileName = relPath.split('/').pop() || '';
+        if (ADDITIONAL_EXCLUDES.has(fileName))
+            continue;
+        const fullPath = join(dirPath, relPath);
+        const sourceFile = tryReadSourceFile(fullPath, rootPath);
+        if (sourceFile)
+            files.push(sourceFile);
+    }
+    return files;
+}
+export function readSourceFiles(dirPath, paths) {
+    const files = [];
+    for (const path of paths) {
+        const fullPath = isAbsolute(path) ? path : join(dirPath, path);
+        const sourceFile = tryReadSourceFile(fullPath, dirPath);
+        if (sourceFile)
+            files.push(sourceFile);
+    }
+    return files;
+}
+export async function ignoredByGit(absolutePaths) {
+    const ignored = new Set();
+    for (const [dir, names] of groupByDirectory(absolutePaths)) {
+        for (const chunk of chunkFileList(names)) {
+            const result = await runCommand('git', ['check-ignore', '--', ...chunk], dir);
+            if (result.exitCode !== 0)
+                continue;
+            for (const line of result.stdout.split('\n')) {
+                if (line)
+                    ignored.add(join(dir, line));
+            }
+        }
+    }
+    return ignored;
+}
+function groupByDirectory(absolutePaths) {
+    const byDir = new Map();
+    for (const path of absolutePaths) {
+        const dir = dirname(path);
+        const group = byDir.get(dir);
+        if (group)
+            group.push(basename(path));
+        else
+            byDir.set(dir, [basename(path)]);
+    }
+    return byDir;
+}
+export async function filterSourceFiles(paths) {
+    const candidates = paths.filter((path) => isAbsolute(path) && SOURCE_EXTENSIONS.has(extname(path).toLowerCase()));
+    if (candidates.length === 0)
+        return [];
+    const ignored = await ignoredByGit(candidates);
+    return candidates.filter((path) => !ignored.has(path));
+}
+export function attributeToTrackedDirectories(spaceRoot, directories, files) {
+    const root = resolve(spaceRoot);
+    const candidates = new Map([['.', root]]);
+    for (const dir of directories) {
+        if (!candidates.has(dir.path))
+            candidates.set(dir.path, resolve(root, dir.path));
+    }
+    const attributed = new Map();
+    for (const file of files) {
+        const absolute = resolve(file);
+        if (!isInside(root, absolute))
+            continue;
+        const [path, dir] = deepestContaining(candidates, absolute);
+        const entry = attributed.get(path);
+        if (entry)
+            entry.files.push(relative(dir, absolute));
+        else
+            attributed.set(path, { path, files: [relative(dir, absolute)] });
+    }
+    return [...attributed.values()];
+}
+function isInside(dir, path) {
+    return path === dir || path.startsWith(`${dir}/`);
+}
+function deepestContaining(candidates, absolute) {
+    let deepest;
+    for (const candidate of candidates) {
+        if (!isInside(candidate[1], absolute))
+            continue;
+        if (!deepest || candidate[1].length > deepest[1].length)
+            deepest = candidate;
+    }
+    if (!deepest)
+        throw new Error(`${absolute} is inside no candidate directory`);
+    return deepest;
+}
+export function filesByExt(files, exts) {
+    const set = new Set(exts.map((e) => e.toLowerCase()));
+    const out = [];
+    for (const f of files) {
+        if (set.has(extname(f.path).toLowerCase()))
+            out.push(f.relativePath);
+    }
+    return out;
+}
+const TEST_FOLDER_SEGMENTS = ['__tests__', '__mocks__', 'tests', 'test', 'e2e', 'spec'];
+const TEST_FILE_PATTERNS = [
+    /\.(test|spec)\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/,
+    /_test\.(go|py)$/,
+    /^test_.+\.py$/,
+];
+function pathHasTestFolder(path) {
+    for (const segment of TEST_FOLDER_SEGMENTS) {
+        if (path.includes(`/${segment}/`) || path.startsWith(`${segment}/`))
+            return true;
+    }
+    return false;
+}
+function fileNameLooksLikeTest(name) {
+    for (const pattern of TEST_FILE_PATTERNS) {
+        if (pattern.test(name))
+            return true;
+    }
+    return false;
+}
+export function isTestFile(relativePath) {
+    const path = relativePath.replace(/\\/g, '/').toLowerCase();
+    if (pathHasTestFolder(path))
+        return true;
+    const name = path.split('/').pop() ?? path;
+    return fileNameLooksLikeTest(name);
+}
+const GENERATED_PATH_SEGMENTS = [
+    '/dist/', '/build/', '/.next/', '/out/', '/.output/',
+    '/generated/', '/__generated__/', '/coverage/', '/.turbo/',
+];
+const CONFIG_BASENAMES = new Set([
+    'package.json', 'tsconfig.json', 'biome.json', 'biome.jsonc',
+    '.eslintrc', '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json',
+    '.prettierrc', '.prettierrc.json', '.prettierrc.js',
+    'babel.config.js', '.babelrc', 'jest.config.js', 'vitest.config.ts',
+]);
+const CONFIG_FILENAME_PATTERNS = [
+    /\.config\.(ts|tsx|js|jsx|mjs|cjs|cts|mts|json)$/,
+    /^tsconfig\..+\.json$/,
+];
+export function classifyFileRole(relativePath) {
+    const path = relativePath.replace(/\\/g, '/').toLowerCase();
+    if (isTestFile(path))
+        return 'test';
+    const withSlash = path.startsWith('/') ? path : `/${path}`;
+    if (GENERATED_PATH_SEGMENTS.some((seg) => withSlash.includes(seg)))
+        return 'generated';
+    const name = path.split('/').pop() ?? path;
+    if (CONFIG_BASENAMES.has(name) || CONFIG_FILENAME_PATTERNS.some((re) => re.test(name)))
+        return 'config';
+    return 'production';
+}
+export function chunkFileList(paths, size = 400) {
+    if (paths.length === 0)
+        return [];
+    const chunks = [];
+    for (let i = 0; i < paths.length; i += size) {
+        chunks.push(paths.slice(i, i + size));
+    }
+    return chunks;
+}
+export const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
+export function runCommand(cmd, args, cwd, envOverrides, timeoutMs = DEFAULT_COMMAND_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const proc = spawn(cmd, args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+            env: envOverrides ? { ...process.env, ...envOverrides } : undefined,
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (d) => { stdout += d.toString(); });
+        proc.stderr?.on('data', (d) => { stderr += d.toString(); });
+        proc.on('close', (code) => {
+            const timedOut = proc.killed && code === null;
+            resolve({ stdout, stderr, exitCode: code ?? 1, ...(timedOut ? { timedOut: true } : {}) });
+        });
+        proc.on('error', (err) => resolve({ stdout: '', stderr: err.message, exitCode: 1 }));
+    });
+}

package/dist/server/services/websocket/quality-triage-agent.js

@@ -0,0 +1,101 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { ResilientRunner } from '../../cli/headless/resilient-runner.js';
+import { readOnlyDisallowedTools, readOnlyRefusal } from '../../engines/read-only.js';
+import { loadSkillPrompt } from '../plan/agent-loader.js';
+import { jsonCandidates } from './quality-types.js';
+const VALID_STATUSES = new Set(['confirmed', 'likely-fp', 'uncertain']);
+const VALID_SEVERITIES = new Set(['critical', 'high', 'medium', 'low']);
+export function buildTriagePrompt(dirPath, findings) {
+    const findingsJson = JSON.stringify(findings.map((f, i) => ({
+        id: i + 1,
+        severity: f.severity,
+        category: f.category,
+        file: f.file,
+        line: f.line,
+        title: f.title,
+        description: f.description,
+    })), null, 2);
+    const fromSkill = loadSkillPrompt('triage-findings', { dirPath, findingsJson });
+    if (fromSkill)
+        return fromSkill;
+    return `You are triaging automated code-quality findings for precision. Working directory: "${dirPath}". Read the cited files and classify each finding below as "confirmed" (a real issue worth fixing), "likely-fp" (technically flagged but not an actual problem here — e.g. a long but cohesive file), or "uncertain". Trust linters/build/format/security findings by default; apply judgment to file-length, function-length, and complexity. Do NOT invent new findings or fix anything.\n\n## Findings to triage\n\n${findingsJson}\n\nOutput EXACTLY one JSON code block: {"verdicts":[{"id":1,"status":"confirmed|likely-fp|uncertain","confidence":0.9,"rationale":"...","severity":"critical|high|medium|low"}]}`;
+}
+function toTriageVerdict(v) {
+    if (typeof v.id !== 'number')
+        return null;
+    const status = v.status;
+    if (!VALID_STATUSES.has(status))
+        return null;
+    return {
+        id: v.id,
+        status: status,
+        confidence: typeof v.confidence === 'number' ? Math.max(0, Math.min(1, v.confidence)) : 0.5,
+        rationale: typeof v.rationale === 'string' ? v.rationale : '',
+        severity: VALID_SEVERITIES.has(v.severity) ? v.severity : undefined,
+    };
+}
+export function parseTriageResponse(response) {
+    for (const candidate of jsonCandidates(response)) {
+        try {
+            const parsed = JSON.parse(candidate);
+            if (!Array.isArray(parsed.verdicts))
+                continue;
+            return parsed.verdicts.map(toTriageVerdict).filter((v) => v !== null);
+        }
+        catch {
+        }
+    }
+    return [];
+}
+export function applyTriage(findings, verdicts) {
+    const byId = new Map(verdicts.map((v) => [v.id, v]));
+    return findings.map((f, i) => {
+        const v = byId.get(i + 1);
+        if (!v)
+            return f;
+        return {
+            ...f,
+            status: v.status,
+            confidence: v.confidence,
+            triageRationale: v.rationale || undefined,
+            severity: v.severity ?? f.severity,
+        };
+    });
+}
+export async function runTriagePass(dirPath, findings, send, signal, 
+model, engineId, effortLevel, fastMode) {
+    if (findings.length === 0)
+        return { findings, ran: false };
+    if (engineId && readOnlyRefusal(engineId))
+        return { findings, ran: false };
+    send(`Triaging ${findings.length} programmatic ${findings.length === 1 ? 'finding' : 'findings'} for relevance...`);
+    const runner = new ResilientRunner({
+        workingDir: dirPath,
+        prompt: buildTriagePrompt(dirPath, findings),
+        policy: 'STANDARD',
+        model,
+        engineId,
+        effortLevel,
+        fastMode,
+        disallowedTools: readOnlyDisallowedTools(),
+        stallWarningMs: 180_000,
+        stallKillMs: 600_000,
+        stallHardCapMs: 1_800_000,
+        logLabel: 'quality-triage',
+        abortSignal: signal,
+    });
+    const result = await runner.run();
+    if (signal?.aborted)
+        return { findings, ran: false };
+    const verdicts = parseTriageResponse(result.assistantResponse || '');
+    if (verdicts.length === 0) {
+        return { findings, ran: false };
+    }
+    const triaged = applyTriage(findings, verdicts);
+    const hidden = triaged.filter((f) => f.status === 'likely-fp').length;
+    if (hidden > 0) {
+        send(`Triage filtered ${hidden} likely false ${hidden === 1 ? 'positive' : 'positives'}`);
+    }
+    return { findings: triaged, ran: true };
+}

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

@@ -0,0 +1,149 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const STRUCTURAL_CATEGORIES = new Set([
+    'file-length',
+    'function-length',
+    'parameters',
+    'nesting',
+    'returns',
+    'tech-debt',
+    'duplication',
+]);
+export function findingCountsTowardGrade(f) {
+    return f.status !== 'uncertain' && f.status !== 'likely-fp' && f.dismissal === undefined;
+}
+export const ECOSYSTEM_TOOLS = {
+    node: [
+        { name: 'eslint', check: ['npx', 'eslint', '--version'], category: 'linter', installCmd: 'npm install -D eslint' },
+        { name: 'biome', check: ['npx', '@biomejs/biome', '--version'], category: 'linter', installCmd: 'npm install -D @biomejs/biome' },
+        { name: 'prettier', check: ['npx', 'prettier', '--version'], category: 'formatter', installCmd: 'npm install -D prettier' },
+        { name: 'typescript', check: ['npx', 'tsc', '--version'], category: 'general', installCmd: 'npm install -D typescript' },
+        { name: 'jscpd', check: ['npx', '--no-install', 'jscpd', '--version'], category: 'general', installCmd: 'npm install -D jscpd' },
+    ],
+    python: [
+        { name: 'ruff', check: ['ruff', '--version'], category: 'linter', installCmd: 'uv tool install ruff || pip install ruff' },
+        { name: 'black', check: ['black', '--version'], category: 'formatter', installCmd: 'uv tool install black || pip install black' },
+        { name: 'radon', check: ['radon', '--version'], category: 'complexity', installCmd: 'uv tool install radon || pip install radon' },
+        { name: 'pip-audit', check: ['pip-audit', '--version'], category: 'security', installCmd: 'pip install pip-audit' },
+    ],
+    rust: [
+        { name: 'clippy', check: ['cargo', 'clippy', '--version'], category: 'linter', installCmd: 'rustup component add clippy' },
+        { name: 'rustfmt', check: ['rustfmt', '--version'], category: 'formatter', installCmd: 'rustup component add rustfmt' },
+        { name: 'cargo-audit', check: ['cargo', 'audit', '--version'], category: 'security', installCmd: 'cargo install cargo-audit' },
+    ],
+    go: [],
+    swift: [],
+    kotlin: [],
+    unknown: [],
+};
+export const SOURCE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.pyi',
+    '.rs',
+    '.go',
+    '.java', '.kt',
+    '.cs',
+    '.rb',
+    '.php',
+    '.swift',
+    '.c', '.cpp', '.h', '.hpp',
+]);
+export const ADDITIONAL_EXCLUDES = new Set([
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'bun.lockb',
+    'bun.lock',
+    'composer.lock',
+    'Gemfile.lock',
+    'Cargo.lock',
+    'poetry.lock',
+    'go.sum',
+]);
+export const FILE_LENGTH_THRESHOLD = 300;
+export const FUNCTION_LENGTH_THRESHOLD = 50;
+export const PARAM_COUNT_THRESHOLD = 4;
+export const NESTING_DEPTH_THRESHOLD = 4;
+export const RETURN_COUNT_THRESHOLD = 5;
+export const TOTAL_STEPS = 12;
+export const ANALYZER_FINDING_BOUND = 5000;
+export function hasInstalledToolInCategory(installedSet, ecosystems, category) {
+    for (const eco of ecosystems) {
+        const specs = ECOSYSTEM_TOOLS[eco] || [];
+        for (const spec of specs) {
+            if (spec.category === category && installedSet.has(spec.name))
+                return true;
+        }
+    }
+    return false;
+}
+export function biomeSeverity(severity) {
+    if (severity === 'error')
+        return 'high';
+    if (severity === 'warning')
+        return 'medium';
+    return 'low';
+}
+const BIOME_COGNITIVE_COMPLEXITY_RULE = 'noExcessiveCognitiveComplexity';
+function biomeRuleGroup(category) {
+    const parts = (category || '').split('/');
+    return { group: parts.length >= 2 ? parts[parts.length - 2] : '', rule: parts[parts.length - 1] || '' };
+}
+export function biomeGroupSeverity(category, emitted) {
+    const { group, rule } = biomeRuleGroup(category);
+    if (group === 'security')
+        return 'high';
+    if (group === 'correctness')
+        return emitted === 'error' ? 'high' : 'medium';
+    if (group === 'suspicious')
+        return 'medium';
+    if (group === 'complexity')
+        return rule === BIOME_COGNITIVE_COMPLEXITY_RULE ? biomeSeverity(emitted) : 'low';
+    if (group === 'style' || group === 'a11y' || group === 'performance' || group === 'nursery') {
+        return 'low';
+    }
+    return biomeSeverity(emitted);
+}
+export function isBiomeComplexityDiagnostic(d) {
+    return (d.category || '').includes('/complexity/');
+}
+export function isEslintComplexityRule(ruleId) {
+    if (!ruleId)
+        return false;
+    return ruleId === 'complexity' || ruleId.endsWith('-complexity') || ruleId.endsWith('/complexity');
+}
+function biomeDiagLine(location, content) {
+    const start = location?.start;
+    if (typeof start?.line === 'number')
+        return start.line;
+    const span = location?.span;
+    if (!Array.isArray(span) || typeof span[0] !== 'number' || content === undefined)
+        return null;
+    const offset = Math.max(0, Math.min(span[0], Buffer.byteLength(content, 'utf8')));
+    const before = Buffer.from(content, 'utf8').subarray(0, offset).toString('utf8');
+    return before.split('\n').length;
+}
+export function biomeDiagToFinding(d, category, contentOf) {
+    const rawCategory = d.category || '';
+    const sev = biomeGroupSeverity(rawCategory, d.severity);
+    const location = d.location;
+    const file = location?.path || '';
+    const message = d.message;
+    const desc = (typeof message === 'object' ? message?.text : message) || '';
+    const ruleName = rawCategory.split('/').pop() || 'Issue';
+    return {
+        severity: sev,
+        category: biomeRuleGroup(rawCategory).group === 'security' ? 'security' : category,
+        file,
+        line: biomeDiagLine(location, contentOf?.(file)),
+        title: ruleName,
+        description: desc,
+    };
+}
+export function jsonCandidates(reply) {
+    const fenced = [/```json\s*([\s\S]*)```/, /```json\s*([\s\S]*?)```/, /```\s*([\s\S]*)```/, /```\s*([\s\S]*?)```/]
+        .map((pattern) => reply.match(pattern)?.[1]?.trim())
+        .filter((candidate) => !!candidate);
+    const braces = reply.match(/\{[\s\S]*\}/)?.[0];
+    return [...fenced, ...(braces ? [braces] : []), reply.trim()];
+}

package/dist/server/services/websocket/recommended-answers.js

@@ -0,0 +1,28 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+const RECOMMENDED_MARKER = '(recommended)';
+export function selectRecommendedAnswers(questions) {
+    const answers = {};
+    for (const q of questions) {
+        if (q.options.length === 0)
+            continue;
+        const recommended = q.options.filter((o) => o.label.toLowerCase().includes(RECOMMENDED_MARKER));
+        if (q.multiSelect) {
+            answers[q.question] =
+                recommended.length > 0
+                    ? recommended.map((o) => o.label).join(', ')
+                    : q.options[0].label;
+        }
+        else {
+            answers[q.question] =
+                recommended.length > 0 ? recommended[0].label : q.options[0].label;
+        }
+    }
+    return answers;
+}
+export function buildLateAnswerPrompt(answers) {
+    const bullets = Object.entries(answers)
+        .map(([question, answer]) => `- ${question}: ${answer}`)
+        .join('\n');
+    return `Following up on the question(s) you asked me earlier — here are my answers:\n${bullets}\nPlease incorporate these and continue.`;
+}