@emeryld/manager 1.1.0 → 1.3.0

package/dist/format-checker/cli/prompts.js

@@ -1,7 +1,8 @@
 import { colors } from '../../utils/log.js';
-import { stdin as input, stdout as output } from 'node:process';
-import { askLine } from '../../prompts.js';
+import { stdin as input } from 'node:process';
+import { askLine, promptSingleKey } from '../../prompts.js';
 import { formatValue, parseInteractiveValue, SETTING_DESCRIPTORS, validateLimits, } from './settings.js';
+import { promptInteractiveSettings, } from '../../cli/interactive-settings.js';
 const READY_PROMPT = colors.dim('Limits retained. Use the navigation above to adjust and confirm again.');
 export async function promptLimits(defaults) {
     const supportsInteractive = typeof input.setRawMode === 'function' && input.isTTY;
@@ -19,14 +20,16 @@ export async function promptLimits(defaults) {
 }
 async function confirmExecution() {
     const question = colors.cyan('Run the format checker with these limits? (Y/n): ');
-    while (true) {
-        const answer = (await askLine(question)).trim().toLowerCase();
-        if (!answer || answer === 'y' || answer === 'yes')
+    return promptSingleKey(question, (key, raw) => {
+        if (!key)
+            return undefined;
+        if (key === 'y' || key === 'yes')
             return true;
-        if (answer === 'n' || answer === 'no')
+        if (key === 'n' || key === 'no')
             return false;
-        console.log(colors.yellow('Answer "yes" or "no", or press Enter to proceed.'));
-    }
+        console.log(colors.yellow('Answer "yes" or "no".'));
+        return undefined;
+    });
 }
 async function promptLimitsSequential(defaults) {
     console.log(colors.dim('Enter a number to override a limit or press Enter to keep the default.'));
@@ -44,193 +47,24 @@ async function promptLimitsSequential(defaults) {
     };
 }
 async function promptLimitsInteractive(defaults) {
-    if (typeof input.setRawMode !== 'function' || !input.isTTY) {
-        return promptLimitsSequential(defaults);
-    }
-    return new Promise((resolve) => {
-        const wasRaw = input.isRaw;
-        if (!wasRaw) {
-            input.setRawMode(true);
-            input.resume();
-        }
-        output.write('\x1b[?25l');
-        const state = {
-            selectedIndex: 0,
-            editingIndex: null,
-            editBuffer: '',
-            justFocused: false,
-            errorMessage: '',
-            renderedLines: 0,
-        };
-        const limits = { ...defaults };
-        const writableLimits = limits;
-        const cleanup = () => {
-            if (state.renderedLines > 0) {
-                output.write(`\x1b[${state.renderedLines}A`);
-                output.write('\x1b[0J');
-                state.renderedLines = 0;
-            }
-            output.write('\x1b[?25h');
-            if (!wasRaw) {
-                input.setRawMode(false);
-                input.pause();
-            }
-            input.off('data', onData);
-        };
-        const finalize = () => {
-            cleanup();
-            console.log();
-            resolve(limits);
-        };
-        const render = () => {
-            const lines = buildInteractiveLines(limits, state.selectedIndex, state.editingIndex, state.editBuffer, state.errorMessage);
-            if (state.renderedLines > 0) {
-                output.write(`\x1b[${state.renderedLines}A`);
-                output.write('\x1b[0J');
-            }
-            lines.forEach((line) => console.log(line));
-            state.renderedLines = lines.length;
-        };
-        const startEditing = () => {
-            state.editingIndex = state.selectedIndex;
-            state.editBuffer = '';
-            state.justFocused = true;
-            state.errorMessage = '';
-        };
-        const moveSelection = (delta) => {
-            state.selectedIndex =
-                (state.selectedIndex + delta + SETTING_DESCRIPTORS.length) %
-                    SETTING_DESCRIPTORS.length;
-            state.editingIndex = null;
-            state.editBuffer = '';
-            state.justFocused = false;
-            state.errorMessage = '';
-            render();
-        };
-        const commitEdit = () => {
-            if (state.editingIndex === null)
-                return;
-            const descriptor = SETTING_DESCRIPTORS[state.editingIndex];
-            const parsed = parseInteractiveValue(descriptor, state.editBuffer);
-            if (parsed.error) {
-                state.errorMessage = parsed.error;
-                process.stdout.write('\x07');
-                render();
-                return;
-            }
-            if (parsed.value !== undefined) {
-                writableLimits[descriptor.key] = parsed.value;
-            }
-            state.editingIndex = null;
-            state.editBuffer = '';
-            state.justFocused = false;
-            state.errorMessage = '';
-            render();
-        };
-        const handlePrintable = (typedChar) => {
-            if (state.editingIndex !== state.selectedIndex) {
-                startEditing();
-            }
-            if (state.justFocused) {
-                state.editBuffer = typedChar;
-                state.justFocused = false;
-            }
-            else {
-                state.editBuffer += typedChar;
-            }
-            render();
-        };
-        const handleBackspace = () => {
-            if (state.editingIndex !== state.selectedIndex) {
-                startEditing();
-                state.justFocused = false;
-            }
-            if (state.editBuffer.length > 0) {
-                state.editBuffer = state.editBuffer.slice(0, -1);
-                render();
-                return;
-            }
-            process.stdout.write('\x07');
-        };
-        const onData = (buffer) => {
-            const ascii = buffer.length === 1 ? buffer[0] : undefined;
-            const isPrintable = ascii !== undefined && ascii >= 0x20 && ascii <= 0x7e;
-            const typedChar = isPrintable && ascii !== undefined ? String.fromCharCode(ascii) : '';
-            const isArrowUp = buffer.equals(Buffer.from([0x1b, 0x5b, 0x41]));
-            const isArrowDown = buffer.equals(Buffer.from([0x1b, 0x5b, 0x42]));
-            const isEnter = buffer.length === 1 && (buffer[0] === 0x0d || buffer[0] === 0x0a);
-            const isEscape = buffer.length === 1 && buffer[0] === 0x1b;
-            const isCtrlC = buffer.length === 1 && buffer[0] === 0x03;
-            const isBackspace = buffer.length === 1 && (buffer[0] === 0x7f || buffer[0] === 0x08);
-            if (isCtrlC || isEscape) {
-                cleanup();
-                process.exit(1);
-            }
-            if (isArrowUp ||
-                (buffer.length === 1 && (buffer[0] === 0x6b || buffer[0] === 0x4b))) {
-                moveSelection(-1);
-                return;
-            }
-            if (isArrowDown ||
-                (buffer.length === 1 && (buffer[0] === 0x6a || buffer[0] === 0x4a))) {
-                moveSelection(1);
-                return;
-            }
-            if (isEnter) {
-                if (state.editingIndex === state.selectedIndex) {
-                    commitEdit();
-                    return;
-                }
-                const validation = validateLimits(limits);
-                if (validation) {
-                    state.errorMessage = validation;
-                    process.stdout.write('\x07');
-                    render();
-                    return;
-                }
-                finalize();
-                return;
-            }
-            if (isBackspace) {
-                handleBackspace();
-                return;
-            }
-            if (isPrintable && typedChar) {
-                handlePrintable(typedChar);
-                return;
-            }
-            process.stdout.write('\x07');
-        };
-        input.on('data', onData);
-        render();
+    const descriptors = SETTING_DESCRIPTORS.map((descriptor) => ({
+        key: descriptor.key,
+        label: descriptor.label,
+        unit: descriptor.unit,
+        format: (value) => formatValue(value, descriptor),
+        parse: (buffer) => parseInteractiveValue(descriptor, buffer),
+    }));
+    return promptInteractiveSettings({
+        title: 'Format checker settings (type to edit values)',
+        descriptors,
+        initial: defaults,
+        instructions: [
+            'Use ↑/↓ to change rows, type to replace the highlighted value, Backspace to clear characters, and Enter to validate and confirm the selection.',
+            'Press Esc/Ctrl+C to abort, or hit Enter again after reviewing the summary to continue.',
+        ],
+        validate: validateLimits,
     });
 }
-function buildInteractiveLines(limits, selectedIndex, editingIndex, editBuffer, errorMessage) {
-    const heading = colors.bold('Format checker settings (type to edit values)');
-    const lines = [heading, ''];
-    SETTING_DESCRIPTORS.forEach((descriptor, index) => {
-        const isSelected = index === selectedIndex;
-        const pointer = isSelected ? colors.green('➤') : '  ';
-        const label = descriptor.unit
-            ? `${descriptor.label} (${descriptor.unit})`
-            : descriptor.label;
-        const isActive = editingIndex === index;
-        const baseValue = formatValue(limits[descriptor.key], descriptor);
-        const displayValue = isActive
-            ? colors.yellow(editBuffer.length > 0 ? editBuffer : baseValue)
-            : colors.magenta(baseValue);
-        const labelColor = isSelected ? colors.green : colors.cyan;
-        const line = `${pointer} ${labelColor(label)}: ${displayValue}`;
-        lines.push(line);
-    });
-    lines.push('');
-    lines.push(colors.dim('Use ↑/↓ to change rows, type to replace the highlighted value, Backspace to clear characters, and Enter to validate and confirm the selection.'));
-    lines.push(colors.dim('Press Esc/Ctrl+C to abort, or hit Enter again after reviewing the summary to continue.'));
-    if (errorMessage) {
-        lines.push(colors.red(`⚠ ${errorMessage}`));
-    }
-    return lines;
-}
 async function promptNumber(label, fallback, unit, options) {
     const question = colors.cyan(`${label} (${unit}) [default ${fallback}]: `);
     while (true) {

package/dist/format-checker/index.js

@@ -1,4 +1,7 @@
 import { colors } from '../utils/log.js';
+import { captureConsoleOutput, exportReportLines, promptExportMode, } from '../utils/export.js';
+import { promptDirectorySelection, describeDirectorySelection } from '../directory-picker.js';
+import { runHelperCli } from '../helper-cli.js';
 import { rootDir } from '../helper-cli/env.js';
 import { loadFormatLimits, } from './config.js';
 import { collectSourceFiles, analyzeFiles } from './scan/index.js';
@@ -8,11 +11,57 @@ import { parseScanCliArgs, printScanUsage } from './cli/options.js';
 export async function runFormatChecker() {
     console.log(colors.cyan('Gathering defaults from .vscode/settings.json (manager.formatChecker)'));
     const defaults = await loadFormatLimits();
-    const limits = await promptLimits(defaults);
-    await executeFormatCheck(limits);
+    let limits = defaults;
+    let exportMode = 'console';
+    while (true) {
+        let lastAction;
+        const scripts = [
+            {
+                name: 'Run format checker',
+                emoji: '🧮',
+                description: `${formatLimitsSummary(limits)} · export=${exportMode}`,
+                handler: async () => {
+                    const selection = await promptDirectorySelection({
+                        title: 'Select directory for format scan',
+                    });
+                    if (!selection)
+                        return;
+                    lastAction = 'run';
+                    await executeFormatCheck(limits, exportMode, selection.absolutePath, describeDirectorySelection(selection));
+                },
+            },
+            {
+                name: 'Adjust limits',
+                emoji: '⚙️',
+                description: formatLimitsSummary(limits),
+                handler: async () => {
+                    limits = await promptLimits(limits);
+                    lastAction = 'configure';
+                },
+            },
+            {
+                name: 'Change export mode',
+                emoji: '📤',
+                description: `Current: ${exportMode}`,
+                handler: async () => {
+                    exportMode = await promptExportMode();
+                    lastAction = 'export';
+                },
+            },
+        ];
+        const ran = await runHelperCli({
+            title: 'Format checker helper',
+            scripts,
+            argv: [],
+        });
+        if (!ran)
+            return;
+        if (lastAction === 'run')
+            return;
+    }
 }
 export async function runFormatCheckerScanCli(argv) {
-    const { overrides, help } = parseScanCliArgs(argv);
+    const { overrides, help, exportMode } = parseScanCliArgs(argv);
     if (help) {
         printScanUsage();
         return;
@@ -20,19 +69,30 @@ export async function runFormatCheckerScanCli(argv) {
     const defaults = await loadFormatLimits();
     const limits = { ...defaults, ...overrides };
     console.log(colors.cyan('Running format checker scan (machine-friendly)'));
-    await executeFormatCheck(limits);
+    await executeFormatCheck(limits, exportMode);
 }
-async function executeFormatCheck(limits) {
-    console.log(colors.magenta('Scanning workspace for source files...'));
-    const files = await collectSourceFiles(rootDir);
+async function executeFormatCheck(limits, exportMode, scanRoot = rootDir, scopeLabel = 'workspace') {
+    console.log(colors.magenta(`Scanning ${scopeLabel} for source files...`));
+    const files = await collectSourceFiles(scanRoot);
     if (files.length === 0) {
         console.log(colors.yellow('No source files were found to analyze.'));
         return;
     }
     console.log(colors.magenta(`Analyzing ${files.length} files`));
     const violations = await analyzeFiles(files, limits);
-    const hadViolations = reportViolations(violations, limits.reportingMode);
+    const hadViolations = await handleViolations(violations, limits.reportingMode, exportMode);
     if (!hadViolations) {
         console.log(colors.green('Workspace meets the configured format limits.'));
     }
 }
+async function handleViolations(violations, reportingMode, exportMode) {
+    if (exportMode === 'console') {
+        return reportViolations(violations, reportingMode);
+    }
+    const { result, lines } = captureConsoleOutput(() => reportViolations(violations, reportingMode));
+    await exportReportLines('format-checker', 'txt', lines);
+    return result;
+}
+function formatLimitsSummary(limits) {
+    return `limits: fn≤${limits.maxFunctionLength} · indent≤${limits.maxIndentationDepth} · reporting=${limits.reportingMode} · exportOnly=${limits.exportOnly}`;
+}

package/dist/format-checker/report.js

@@ -109,6 +109,9 @@ function logViolationEntry(entry, messagePrefix, locationDescriptor) {
             console.log(`    ${colors.yellow(line)}`);
         });
     }
+    if (entry.requiredVariables?.length) {
+        console.log(`    ${colors.dim('Required variables:')} ${entry.requiredVariables.join(', ')}`);
+    }
     if (locationDescriptor) {
         console.log(`    ${colors.dim(locationDescriptor)}`);
     }

package/dist/format-checker/scan/analysis.js

@@ -2,7 +2,9 @@ import { readFile } from 'node:fs/promises';
 import { collectDuplicateViolations, recordDuplicateLines, } from './duplicates.js';
 import { countIndentation, groupIndentationViolations, } from './indentation.js';
 import { collectFunctionRecords } from './functions.js';
-import { markImportLines, normalizeLine } from './utils.js';
+import { markImportLines, normalizeLine, resolveScriptKind } from './utils.js';
+import { collectRequiredVariables } from './variables.js';
+import * as ts from 'typescript';
 export async function analyzeFiles(files, limits) {
     const violations = [];
     const duplicateMap = new Map();
@@ -45,12 +47,19 @@ async function analyzeSingleFile(filePath, limits, duplicates) {
             indentationViolations.push({ line: index + 1, indent });
         }
     });
-    recordDuplicateLines(normalizedLines, filePath, limits, duplicates);
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.ESNext, true, resolveScriptKind(filePath));
+    recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines);
     const indentationGroups = groupIndentationViolations(indentationViolations, lines, limits.maxIndentationDepth);
     indentationGroups
         .sort((a, b) => b.severity - a.severity)
         .slice(0, 4)
         .forEach((group) => {
+        const requiredVariables = collectRequiredVariables(sourceFile, lines, {
+            startLine: group.startLine,
+            startColumn: group.startColumn,
+            endLine: group.endLine,
+            endColumn: group.endColumn,
+        });
         violations.push({
             type: 'indentation',
             file: filePath,
@@ -59,9 +68,10 @@ async function analyzeSingleFile(filePath, limits, duplicates) {
             message: `Indentation level ${group.maxIndent} exceeds max ${limits.maxIndentationDepth}`,
             snippet: group.snippet,
             detail: `${group.startLine}:${group.startColumn}/${group.endLine}:${group.endColumn}`,
+            requiredVariables,
         });
     });
-    const allFunctions = collectFunctionRecords(content, filePath);
+    const allFunctions = collectFunctionRecords(sourceFile);
     const functions = limits.exportOnly
         ? allFunctions.filter((record) => record.isExported)
         : allFunctions;

package/dist/format-checker/scan/duplicates.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { getLineColumnRange } from './utils.js';
-export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates) {
+import { collectRequiredVariables } from './variables.js';
+export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines) {
     const minLines = Math.max(1, limits.minDuplicateLines);
     if (limits.minDuplicateLines <= 0 || minLines === 1) {
         normalizedLines.forEach((entry, index) => {
@@ -12,7 +13,7 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
             if (entry.isImport)
                 return;
             const { startColumn, endColumn } = getLineColumnRange(entry.raw);
-            addDuplicateOccurrence(duplicates, entry.normalized, filePath, index + 1, startColumn, index + 1, endColumn, snippet);
+            addDuplicateOccurrence(duplicates, entry.normalized, filePath, index + 1, startColumn, index + 1, endColumn, snippet, sourceFile, lines);
         });
         return;
     }
@@ -47,10 +48,10 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
         const endLine = i + 1 + lastNonEmptyIndex;
         const { startColumn } = getLineColumnRange(slice[firstNonEmptyIndex].raw);
         const { endColumn } = getLineColumnRange(slice[lastNonEmptyIndex].raw);
-        addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet);
+        addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet, sourceFile, lines);
     }
 }
-function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet) {
+function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet, sourceFile, lines) {
     const tracker = duplicates.get(key);
     if (tracker) {
         tracker.count += 1;
@@ -69,6 +70,12 @@ function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColum
     duplicates.set(key, {
         count: 1,
         snippet,
+        requiredVariables: collectRequiredVariables(sourceFile, lines, {
+            startLine,
+            startColumn,
+            endLine,
+            endColumn,
+        }),
         occurrences: [
             {
                 file: filePath,
@@ -102,6 +109,7 @@ export function collectDuplicateViolations(duplicates, limits) {
                 .join('\n'),
             snippet: tracker.snippet,
             repeatCount: tracker.count,
+            requiredVariables: tracker.requiredVariables,
         });
     }
     return violations;

package/dist/format-checker/scan/functions.js

@@ -1,7 +1,5 @@
 import * as ts from 'typescript';
-import { resolveScriptKind } from './utils.js';
-export function collectFunctionRecords(content, filePath) {
-    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.ESNext, true, resolveScriptKind(filePath));
+export function collectFunctionRecords(sourceFile) {
     const records = [];
     function visit(node) {
         if ((ts.isFunctionDeclaration(node) ||