@emeryld/manager 1.0.0 → 1.1.0

package/README.md

@@ -15,38 +15,87 @@ Dev dependency built for Codex agents: scan a pnpm workspace, scaffold RRRoutes
 - **Action menu** for the selection:
   - `update dependencies` → runs `pnpm -r update` (or filtered update), stages only dependency files, prompts for a commit message, commits, and pushes.
   - `test` → `pnpm test` (filtered to the package when possible).
+  - `format checker` → prompts for limits, then scans each source file for long functions, deep indentation, too many components/functions, and repeated/similar snippets before reporting offenders.
   - `build` → `pnpm build` (filtered when a single package is selected).
   - `publish` → ensures the working tree is committed, checks registry auth, prompts a version strategy, commits the bump, tags, publishes with pnpm, and pushes tags.
   - `full` → update → test → build → publish in order.
-  - `back` → return to package selection. When a single package is chosen, its `package.json` scripts also appear as runnable entries.
+- `back` → return to package selection. When a single package is chosen, its `package.json` scripts also appear as runnable entries.
+
+## Format checker configuration
+
+`manager-cli` ships with a format checker action that respects defaults in `.vscode/settings.json` under the `manager.formatChecker` key. Define:
+
+| setting | description |
+| --- | --- |
+| `maxFunctionLength` | allowed lines per function |
+| `maxIndentationDepth` | indentation spaces before warning |
+| `maxFunctionsPerFile` | functions allowed in a file |
+| `maxComponentsPerFile` | component abstractions allowed |
+| `maxFileLength` | total lines per file |
+| `maxDuplicateLineOccurrences` | times a similar line can repeat |
+| `minDuplicateLines` | minimum consecutive lines required for repetition warnings |
+| `exportOnly` | limit function/component checks to exported symbols |
+| `indentationWidth` | spaces to count per tab when evaluating indentation depth |
+
+Each run also prompts for overrides, so you can tweak targets without editing the file.
+The override prompt now lists every limit at once; you can move with ↑/↓, type to replace the highlighted value, Backspace to erase characters, and press Enter when the values validate before confirming.
+
+## Format checker scan CLI
+- **Usage**: `pnpm manager-cli scan [flags]` scans the workspace without interactive prompts while honoring defaults in `.vscode/settings.json` under `manager.formatChecker`.
+- **Flags**: override any limit via the table below or run `pnpm manager-cli scan --help`/`-h` to print the same guidance.
+
+| Flag | Description |
+| --- | --- |
+| `--max-function-length <number>` | Maximum lines per function before a violation is reported. |
+| `--max-indentation-depth <number>` | Maximum indentation depth (spaces) that the scanner tolerates. |
+| `--max-functions-per-file <number>` | Maximum number of functions allowed in a source file. |
+| `--max-components-per-file <number>` | Maximum component abstractions permitted per file. |
+| `--max-file-length <number>` | Maximum total lines in a file before the file-length rule triggers. |
+| `--max-duplicate-line-occurrences <number>` | Maximum times a similar line may repeat before it counts as duplication. |
+| `--min-duplicate-lines <number>` | Minimum consecutive duplicate lines needed to trigger the duplicate check (set to `0` to skip the requirement). |
+| `--indentation-width <number>` | Number of spaces counted per tab when measuring indentation depth. |
+| `--export-only <true|false>` | When `true`, component/function counts only consider exported symbols. |
+| `--reporting-mode <group|file>` | Choose `group` (summary by violation type) or `file` (per-file entries). |
+- **Purpose**: give Codex agents, CI pipelines, and automation deterministic scans that print the same violation summaries as the interactive action.
+- **Output**: prints `Format checker violations:` followed by grouped or per-file buckets (with severity, snippets, and location references); when no violations occur you get `Format checker found no violations.` and `Workspace meets the configured format limits.` Colors mirror the interactive report to keep results easy to scan.
 
 ## Non-interactive release (Codex/CI)
-- Syntax: `pnpm manager-cli <pkg|all> --non-interactive [publish flags]`
-- Required: the selection (`<pkg>` or `all`) **and** one of `--bump <type>`, `--sync <version>`, or `--noop` (skip version change but still publish/tag).
-- Flags:
-  - `--non-interactive`, `--ci`, `--yes`, `-y` → auto-confirm prompts.
-  - `--bump <patch|minor|major|prepatch|preminor|premajor|prerelease>` → bump versions (pre* keeps/previews prerelease ids).
-  - `--sync <version>` → set all selected packages to an exact version.
-  - `--tag <dist-tag>` → publish with a custom npm dist-tag (default inferred from prerelease suffix).
-  - `--dry-run` → pass through to `pnpm publish --dry-run`.
-  - `--provenance` → enable provenance on publish.
-  - `--noop` → skip version change but still tag/publish current versions.
-- Behavior: commits any existing changes before running (prompting for a message), requires registry auth (`pnpm whoami`), and tags/pushes after publish.
-
-## Scaffolding packages
-- Interactive: `pnpm manager-cli create` → prompts for template, path, package name, contract (for server/client), and client kind (for client/fullstack). Uses arrow keys/digits when the terminal supports raw mode.
-- Headless (Codex/CI) flags:
-  - `--list`, `-l` → show available templates.
-  - `--describe`, `-d <variant>` → print scripts/files/notes for a template.
-  - `--variant`, `-v <id>` → pick a template without a prompt (ids below).
-  - `--dir`, `--path`, `-p <path>` → target directory.
-  - `--name`, `-n <pkg>` → package name (defaults to basename of `--dir`).
-  - `--contract <pkg>` → contract import for server/client templates.
-  - `--client-kind <vite-react|expo-react-native>` → choose client stack (client/fullstack).
-  - `--reset` → delete the target directory before scaffolding.
-  - `--skip-install` / `--skip-build` → skip post-create install/build.
-  - `--help`, `-h` → print help.
-- After effects: ensures the target directory exists (warns if non-empty, or wipes it when `--reset`), writes shared tooling files (tsconfig, workspace helpers), scaffolds the template, runs `pnpm install`, then builds the new package and its workspace deps (fallbacks: full workspace build, then package-only build). Each scaffolded package includes its own README with variant-specific scripts.
+- **Syntax**: `pnpm manager-cli <pkg|all> --non-interactive [publish flags]`
+- **Requirements**: provide the selection (`<pkg>` or `all`) and one of `--bump <type>`, `--sync <version>`, or `--noop` (skip the version change but still tag/publish). Use `--non-interactive`, `--ci`, `--yes`, or `-y` interchangeably to answer every prompt in the affirmative.
+- **Behavior**: commits any existing changes (prompting for a message), checks registry auth (`pnpm whoami`), runs `pnpm publish` (filtered when possible), tags, and pushes after a successful release.
+- **Flags**:
+
+| Flag | Description |
+| --- | --- |
+| `--non-interactive`, `--ci`, `--yes`, `-y` | Auto-respond “yes” to every prompt. |
+| `--bump <patch|minor|major|prepatch|preminor|premajor|prerelease>` | Bump versions (pre* keeps or previews prerelease tags). |
+| `--sync <version>` | Set all selected packages to the exact semver you pass. |
+| `--noop` | Skip the version bump but still tag/publish the current versions. |
+| `--tag <dist-tag>` | Publish with a custom npm dist-tag (defaults to prerelease suffix inference). |
+| `--dry-run` | Forward `--dry-run` to `pnpm publish`. |
+| `--provenance` | Enable npm provenance metadata when publishing. |
+
+`--bump`, `--sync`, or `--noop` are mandatory in non-interactive mode. Optional flags like `--tag`, `--dry-run`, and `--provenance` layer additional behavior on top of the release pipeline.
+
+## Create package CLI
+- Interactive: `pnpm manager-cli create` prompts for template, path, package name, contract (for server/client), and client kind (when applicable). The menu accepts ↑/↓/j/k navigation, digits, and arrow keys when raw mode is available.
+- Headless usage: `pnpm manager-cli templates` is a shorthand for `create --list`. Any other flag combination described below will skip prompts and scaffold directly.
+
+| Flag | Description |
+| --- | --- |
+| `--list`, `-l` | List every available template (`rrr-contract`, `rrr-server`, etc.) with their default directories and summaries. |
+| `--describe <variant>`, `-d` | Print the scripts, key files, and notes for a specific template before scaffolding. |
+| `--variant <id>`, `-v` | Choose a template by ID, partial label, or friendly name without hitting the prompts. |
+| `--dir`, `--path`, `-p <path>` | Target directory for the new package (defaults to the variant’s default). |
+| `--name`, `-n <pkg>` | Package name inside `package.json`; defaults to the basename of `--dir`. |
+| `--contract <pkg>` | Contract import to wire into server/client templates. |
+| `--client-kind <vite-react|expo-react-native>` | Pick the client stack for client-friendly templates. |
+| `--reset` | Delete the existing target directory before scaffolding (refuses to reset the workspace root). |
+| `--skip-install` | Do not run `pnpm install` after scaffolding. |
+| `--skip-build` | Skip the post-scaffold build step (only meaningful when not skipping install). |
+| `--help`, `-h` | Show the help text above. |
+
+After scaffolding, helper tooling (tsconfig, workspace helpers, etc.) is ensured, the template is written, and a build/install attempt runs unless skipped. Each generated package ships with its own README explaining variant-specific scripts.
 
 ## Templates at a glance
 | id | default dir | summary | key files |
@@ -69,6 +118,8 @@ Use `pnpm manager-cli create --describe <variant>` to print the scripts, key fil
   `pnpm manager-cli @scope/api --non-interactive --bump minor --tag next`
 - Publish everything with a synced version:  
   `pnpm manager-cli all --non-interactive --sync 1.2.3 --provenance`
+- Run the format checker scan headlessly:  
+  `pnpm manager-cli scan --max-function-length 90 --reporting-mode file`
 
 ## Notes
 - Helper scripts register the bundled `ts-node/esm` loader so the CLI works even when dependencies are hoisted.

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

@@ -0,0 +1,117 @@
+import { colors } from '../../utils/log.js';
+import { parseBooleanInput, parsePositiveInteger, parseReportingModeInput, } from './settings.js';
+export const SCAN_FLAG_DEFINITIONS = [
+    {
+        flag: '--max-function-length',
+        description: 'Maximum function length (lines).',
+        key: 'maxFunctionLength',
+        parser: (value) => parseNumberFlag(value, '--max-function-length'),
+    },
+    {
+        flag: '--max-indentation-depth',
+        description: 'Maximum indentation depth (spaces).',
+        key: 'maxIndentationDepth',
+        parser: (value) => parseNumberFlag(value, '--max-indentation-depth'),
+    },
+    {
+        flag: '--max-functions-per-file',
+        description: 'Maximum functions per file.',
+        key: 'maxFunctionsPerFile',
+        parser: (value) => parseNumberFlag(value, '--max-functions-per-file'),
+    },
+    {
+        flag: '--max-components-per-file',
+        description: 'Maximum components per file.',
+        key: 'maxComponentsPerFile',
+        parser: (value) => parseNumberFlag(value, '--max-components-per-file'),
+    },
+    {
+        flag: '--max-file-length',
+        description: 'Maximum total lines per file.',
+        key: 'maxFileLength',
+        parser: (value) => parseNumberFlag(value, '--max-file-length'),
+    },
+    {
+        flag: '--max-duplicate-line-occurrences',
+        description: 'Allowed repeated/similar line occurrences.',
+        key: 'maxDuplicateLineOccurrences',
+        parser: (value) => parseNumberFlag(value, '--max-duplicate-line-occurrences'),
+    },
+    {
+        flag: '--min-duplicate-lines',
+        description: 'Minimum repeated lines (0 disables minimum).',
+        key: 'minDuplicateLines',
+        parser: (value) => parseNumberFlag(value, '--min-duplicate-lines', { allowZero: true }),
+    },
+    {
+        flag: '--export-only',
+        description: 'Limit checks to exported symbols (true|false).',
+        key: 'exportOnly',
+        parser: (value) => parseBooleanFlag(value),
+    },
+    {
+        flag: '--indentation-width',
+        description: 'Spaces counted per tab when measuring indentation.',
+        key: 'indentationWidth',
+        parser: (value) => parseNumberFlag(value, '--indentation-width'),
+    },
+    {
+        flag: '--reporting-mode',
+        description: 'How violations are grouped (group|file).',
+        key: 'reportingMode',
+        parser: (value) => parseReportingModeFlag(value),
+    },
+];
+export function parseScanCliArgs(argv) {
+    const entries = [];
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === '--help' || token === '-h') {
+            const overrides = Object.fromEntries(entries);
+            return { overrides, help: true };
+        }
+        const definition = SCAN_FLAG_DEFINITIONS.find((def) => def.flag === token);
+        if (!definition) {
+            throw new Error(`Unknown scan option "${token}". Use "pnpm manager-cli scan --help".`);
+        }
+        const rawValue = argv[++i];
+        if (!rawValue) {
+            throw new Error(`Flag "${token}" expects a value.`);
+        }
+        entries.push([
+            definition.key,
+            definition.parser(rawValue),
+        ]);
+    }
+    const overrides = Object.fromEntries(entries);
+    return { overrides, help: false };
+}
+export function printScanUsage() {
+    console.log(colors.bold('Usage: pnpm manager-cli scan [flags]'));
+    console.log(colors.dim('Run the format checker scan without interactive prompts. Defaults respect .vscode/settings.json (manager.formatChecker).'));
+    console.log('');
+    SCAN_FLAG_DEFINITIONS.forEach((definition) => {
+        console.log(`${colors.cyan(definition.flag)}\t${definition.description}`);
+    });
+    console.log('');
+    console.log(colors.dim('Use --help or -h to show this message.'));
+}
+function parseNumberFlag(value, flag, options) {
+    const parsed = parsePositiveInteger(value, options);
+    if (parsed === undefined) {
+        throw new Error(`Flag "${flag}" expects a ${options?.allowZero ? 'non-negative' : 'positive'} integer.`);
+    }
+    return parsed;
+}
+function parseBooleanFlag(raw) {
+    const parsed = parseBooleanInput(raw);
+    if (parsed.error)
+        throw new Error(parsed.error);
+    return parsed.value;
+}
+function parseReportingModeFlag(raw) {
+    const result = parseReportingModeInput(raw);
+    if (result.error)
+        throw new Error(result.error);
+    return result.value;
+}

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

@@ -0,0 +1,276 @@
+import { colors } from '../../utils/log.js';
+import { stdin as input, stdout as output } from 'node:process';
+import { askLine } from '../../prompts.js';
+import { formatValue, parseInteractiveValue, SETTING_DESCRIPTORS, validateLimits, } from './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;
+    let currentLimits = defaults;
+    while (true) {
+        const chosen = supportsInteractive
+            ? await promptLimitsInteractive(currentLimits)
+            : await promptLimitsSequential(currentLimits);
+        const confirmed = await confirmExecution();
+        if (confirmed)
+            return chosen;
+        currentLimits = chosen;
+        console.log(READY_PROMPT);
+    }
+}
+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 true;
+        if (answer === 'n' || answer === 'no')
+            return false;
+        console.log(colors.yellow('Answer "yes" or "no", or press Enter to proceed.'));
+    }
+}
+async function promptLimitsSequential(defaults) {
+    console.log(colors.dim('Enter a number to override a limit or press Enter to keep the default.'));
+    return {
+        maxFunctionLength: await promptNumber('Max function length', defaults.maxFunctionLength, 'lines'),
+        maxIndentationDepth: await promptNumber('Max indentation depth', defaults.maxIndentationDepth, 'spaces'),
+        maxFunctionsPerFile: await promptNumber('Max functions per file', defaults.maxFunctionsPerFile, 'count'),
+        maxComponentsPerFile: await promptNumber('Max components per file', defaults.maxComponentsPerFile, 'count'),
+        maxFileLength: await promptNumber('Max file length', defaults.maxFileLength, 'lines'),
+        maxDuplicateLineOccurrences: await promptNumber('Max repeated/similar lines', defaults.maxDuplicateLineOccurrences, 'occurrences'),
+        minDuplicateLines: await promptNumber('Min duplicate lines required', defaults.minDuplicateLines, 'lines (0 = no minimum)', { allowZero: true }),
+        exportOnly: await promptBoolean('Export-only function checks', defaults.exportOnly),
+        indentationWidth: await promptNumber('Indentation width', defaults.indentationWidth, 'spaces per tab'),
+        reportingMode: await promptReportingMode(defaults.reportingMode),
+    };
+}
+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();
+    });
+}
+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) {
+        const answer = await askLine(question);
+        if (!answer)
+            return fallback;
+        const parsed = Number(answer);
+        if (!Number.isNaN(parsed)) {
+            if (options?.allowZero ? parsed >= 0 : parsed > 0) {
+                return Math.floor(parsed);
+            }
+        }
+        const rangeLabel = options?.allowZero ? 'non-negative' : 'positive';
+        console.log(colors.yellow(`Provide a ${rangeLabel} number or leave blank to keep the default.`));
+    }
+}
+async function promptBoolean(label, fallback) {
+    const question = colors.cyan(`${label} [default ${fallback ? 'yes' : 'no'}]: `);
+    while (true) {
+        const answer = (await askLine(question)).trim().toLowerCase();
+        if (!answer)
+            return fallback;
+        if (['yes', 'y', 'true', '1'].includes(answer))
+            return true;
+        if (['no', 'n', 'false', '0'].includes(answer))
+            return false;
+        console.log(colors.yellow('Please answer "yes" or "no", or leave blank to keep the default.'));
+    }
+}
+async function promptReportingMode(fallback) {
+    const optionsLabel = SETTING_DESCRIPTORS.find((descriptor) => descriptor.key === 'reportingMode')?.options?.join('|') ?? '';
+    const question = colors.cyan(`Reporting mode (${optionsLabel}) [default ${fallback}]: `);
+    while (true) {
+        const answer = (await askLine(question)).trim().toLowerCase();
+        if (!answer)
+            return fallback;
+        const descriptor = SETTING_DESCRIPTORS.find((entry) => entry.key === 'reportingMode');
+        if (descriptor?.options?.includes(answer)) {
+            return answer;
+        }
+        console.log(colors.yellow(`Enter one of ${optionsLabel} or leave blank to keep the default.`));
+    }
+}

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

@@ -0,0 +1,140 @@
+import { REPORTING_MODES } from '../config.js';
+export const SETTING_DESCRIPTORS = [
+    {
+        key: 'maxFunctionLength',
+        label: 'Max function length',
+        unit: 'lines',
+        type: 'number',
+    },
+    {
+        key: 'maxIndentationDepth',
+        label: 'Max indentation depth',
+        unit: 'spaces',
+        type: 'number',
+    },
+    {
+        key: 'maxFunctionsPerFile',
+        label: 'Max functions per file',
+        unit: 'count',
+        type: 'number',
+    },
+    {
+        key: 'maxComponentsPerFile',
+        label: 'Max components per file',
+        unit: 'count',
+        type: 'number',
+    },
+    {
+        key: 'maxFileLength',
+        label: 'Max file length',
+        unit: 'lines',
+        type: 'number',
+    },
+    {
+        key: 'maxDuplicateLineOccurrences',
+        label: 'Max repeated/similar lines',
+        unit: 'occurrences',
+        type: 'number',
+    },
+    {
+        key: 'minDuplicateLines',
+        label: 'Min duplicate lines required',
+        unit: 'lines (0 = no minimum)',
+        type: 'number',
+        allowZero: true,
+    },
+    {
+        key: 'exportOnly',
+        label: 'Export-only function checks',
+        type: 'boolean',
+    },
+    {
+        key: 'indentationWidth',
+        label: 'Indentation width',
+        unit: 'spaces per tab',
+        type: 'number',
+    },
+    {
+        key: 'reportingMode',
+        label: 'Reporting mode',
+        type: 'option',
+        options: REPORTING_MODES,
+    },
+];
+export function formatValue(value, descriptor) {
+    if (descriptor.type === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (descriptor.type === 'option') {
+        return `${value}`;
+    }
+    return `${value}`;
+}
+export function parseInteractiveValue(descriptor, buffer) {
+    const trimmed = buffer.trim();
+    if (trimmed === '')
+        return { value: undefined };
+    if (descriptor.type === 'number') {
+        const parsed = parsePositiveInteger(trimmed, { allowZero: descriptor.allowZero });
+        if (parsed === undefined) {
+            return {
+                error: `${descriptor.label} requires a ${descriptor.allowZero ? 'non-negative' : 'positive'} integer.`,
+            };
+        }
+        return { value: parsed };
+    }
+    if (descriptor.type === 'boolean') {
+        const result = parseBooleanInput(trimmed);
+        if (result.error)
+            return { error: result.error };
+        return { value: result.value };
+    }
+    if (descriptor.type === 'option') {
+        const result = parseReportingModeInput(trimmed);
+        if (result.error)
+            return { error: result.error };
+        return { value: result.value };
+    }
+    return { value: undefined };
+}
+export function validateLimits(limits) {
+    for (const descriptor of SETTING_DESCRIPTORS) {
+        if (descriptor.type === 'number') {
+            const value = limits[descriptor.key];
+            const min = descriptor.allowZero ? 0 : 1;
+            if (!Number.isFinite(value) || value < min) {
+                return `${descriptor.label} must be ${descriptor.allowZero ? 'non-negative' : 'positive'}.`;
+            }
+        }
+    }
+    if (!REPORTING_MODES.includes(limits.reportingMode)) {
+        return `Reporting mode must be one of ${REPORTING_MODES.join(', ')}.`;
+    }
+    return undefined;
+}
+export function parsePositiveInteger(inputValue, options) {
+    const trimmed = inputValue.trim();
+    const num = Number(trimmed);
+    if (!Number.isFinite(num))
+        return undefined;
+    const floored = Math.floor(num);
+    const min = options?.allowZero ? 0 : 1;
+    if (floored < min)
+        return undefined;
+    return floored;
+}
+export function parseBooleanInput(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (['yes', 'y', 'true', '1'].includes(normalized))
+        return { value: true };
+    if (['no', 'n', 'false', '0'].includes(normalized))
+        return { value: false };
+    return { error: 'Provide "true" or "false".' };
+}
+export function parseReportingModeInput(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (REPORTING_MODES.includes(normalized)) {
+        return { value: normalized };
+    }
+    return { error: `Reporting mode must be one of ${REPORTING_MODES.join(', ')}.` };
+}