@emeryld/manager 1.4.0 → 1.4.2

package/README.md

@@ -15,7 +15,7 @@ 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.
+  - `format checker` → prompts for limits, then scans each source file for long functions and class methods, 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.
@@ -27,7 +27,8 @@ Dev dependency built for Codex agents: scan a pnpm workspace, scaffold RRRoutes
 
 | setting | description |
 | --- | --- |
-| `maxFunctionLength` | allowed lines per function |
+| `maxFunctionLength` | allowed lines per function (default 150) |
+| `maxMethodLength` | allowed lines per class method (default 150) |
 | `maxIndentationDepth` | indentation spaces before warning |
 | `maxFunctionsPerFile` | functions allowed in a file |
 | `maxComponentsPerFile` | component abstractions allowed |
@@ -38,9 +39,19 @@ Dev dependency built for Codex agents: scan a pnpm workspace, scaffold RRRoutes
 | `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.
+Long methods inside classes now obey the `maxMethodLength` limit, so class members are scanned even when they aren't individually exported.
 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.
 You can also decide where the report lands: the manager will ask whether to stream the violations to the console or dump them into a temporary file that is opened in your editor (no repo files are modified).
 
+```json
+{
+  "manager.formatChecker": {
+    "maxFunctionLength": 150,
+    "maxMethodLength": 200
+  }
+}
+```
+
 ## 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.
@@ -48,6 +59,7 @@ You can also decide where the report lands: the manager will ask whether to stre
 | Flag | Description |
 | --- | --- |
 | `--max-function-length <number>` | Maximum lines per function before a violation is reported. |
+| `--max-method-length <number>` | Maximum lines per class/instance method 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. |

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

@@ -8,6 +8,12 @@ export const SCAN_FLAG_DEFINITIONS = [
         key: 'maxFunctionLength',
         parser: (value) => parseNumberFlag(value, '--max-function-length'),
     },
+    {
+        flag: '--max-method-length',
+        description: 'Maximum method length (lines).',
+        key: 'maxMethodLength',
+        parser: (value) => parseNumberFlag(value, '--max-method-length'),
+    },
     {
         flag: '--max-indentation-depth',
         description: 'Maximum indentation depth (spaces).',

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

@@ -35,6 +35,7 @@ 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'),
+        maxMethodLength: await promptNumber('Max method length', defaults.maxMethodLength, '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'),

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

@@ -6,6 +6,12 @@ export const SETTING_DESCRIPTORS = [
         unit: 'lines',
         type: 'number',
     },
+    {
+        key: 'maxMethodLength',
+        label: 'Max method length',
+        unit: 'lines',
+        type: 'number',
+    },
     {
         key: 'maxIndentationDepth',
         label: 'Max indentation depth',

package/dist/format-checker/config.js

@@ -4,9 +4,10 @@ import path from 'node:path';
 import { rootDir } from '../helper-cli/env.js';
 export const REPORTING_MODES = ['group', 'file'];
 export const DEFAULT_LIMITS = {
-    maxFunctionLength: 120,
+    maxFunctionLength: 150,
+    maxMethodLength: 150,
     maxIndentationDepth: 6,
-    maxFunctionsPerFile: 16,
+    maxFunctionsPerFile: 25,
     maxComponentsPerFile: 8,
     maxFileLength: 500,
     maxDuplicateLineOccurrences: 3,
@@ -38,6 +39,7 @@ export async function loadFormatLimits() {
         const settingsRecord = settings;
         return {
             maxFunctionLength: coerceNumber(settingsRecord.maxFunctionLength, DEFAULT_LIMITS.maxFunctionLength),
+            maxMethodLength: coerceNumber(settingsRecord.maxMethodLength, DEFAULT_LIMITS.maxMethodLength),
             maxIndentationDepth: coerceNumber(settingsRecord.maxIndentationDepth, DEFAULT_LIMITS.maxIndentationDepth),
             maxFunctionsPerFile: coerceNumber(settingsRecord.maxFunctionsPerFile, DEFAULT_LIMITS.maxFunctionsPerFile),
             maxComponentsPerFile: coerceNumber(settingsRecord.maxComponentsPerFile, DEFAULT_LIMITS.maxComponentsPerFile),

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

@@ -8,13 +8,14 @@ import * as ts from 'typescript';
 export async function analyzeFiles(files, limits) {
     const violations = [];
     const duplicateMap = new Map();
+    const fileSnapshots = new Map();
     for (const file of files) {
-        violations.push(...(await analyzeSingleFile(file, limits, duplicateMap)));
+        violations.push(...(await analyzeSingleFile(file, limits, duplicateMap, fileSnapshots)));
     }
-    violations.push(...collectDuplicateViolations(duplicateMap, limits));
+    violations.push(...collectDuplicateViolations(duplicateMap, limits, fileSnapshots));
     return violations;
 }
-async function analyzeSingleFile(filePath, limits, duplicates) {
+async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
     let content;
     try {
         content = await readFile(filePath, 'utf-8');
@@ -48,7 +49,7 @@ async function analyzeSingleFile(filePath, limits, duplicates) {
         }
     });
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.ESNext, true, resolveScriptKind(filePath));
-    recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines);
+    recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines, fileSnapshots);
     const indentationGroups = groupIndentationViolations(indentationViolations, lines, limits.maxIndentationDepth);
     indentationGroups
         .sort((a, b) => b.severity - a.severity)
@@ -95,13 +96,17 @@ async function analyzeSingleFile(filePath, limits, duplicates) {
         });
     }
     functions.forEach((record) => {
-        if (record.length > limits.maxFunctionLength) {
+        const limit = record.isMethod
+            ? limits.maxMethodLength
+            : limits.maxFunctionLength;
+        if (record.length > limit) {
+            const descriptor = record.isMethod ? 'Method' : 'Function';
             violations.push({
                 type: 'functionLength',
                 file: filePath,
                 line: record.startLine,
-                severity: record.length - limits.maxFunctionLength,
-                message: `Function ${record.name ?? '<anonymous>'} spans ${record.length} lines (max ${limits.maxFunctionLength})`,
+                severity: record.length - limit,
+                message: `${descriptor} ${record.name ?? '<anonymous>'} spans ${record.length} lines (max ${limit})`,
             });
         }
     });

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

@@ -1,8 +1,11 @@
 import path from 'node:path';
 import { getLineColumnRange } from './utils.js';
 import { collectRequiredVariables } from './variables.js';
-export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines) {
+export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines, fileSnapshots) {
     const minLines = Math.max(1, limits.minDuplicateLines);
+    const registerSnapshot = () => {
+        ensureFileSnapshot(fileSnapshots, filePath, normalizedLines, lines, sourceFile);
+    };
     if (limits.minDuplicateLines <= 0 || minLines === 1) {
         normalizedLines.forEach((entry, index) => {
             if (!entry.normalized)
@@ -13,6 +16,7 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
             if (entry.isImport)
                 return;
             const { startColumn, endColumn } = getLineColumnRange(entry.raw);
+            registerSnapshot();
             addDuplicateOccurrence(duplicates, entry.normalized, filePath, index + 1, startColumn, index + 1, endColumn, snippet, sourceFile, lines);
         });
         return;
@@ -48,6 +52,7 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
         const endLine = i + 1 + lastNonEmptyIndex;
         const { startColumn } = getLineColumnRange(slice[firstNonEmptyIndex].raw);
         const { endColumn } = getLineColumnRange(slice[lastNonEmptyIndex].raw);
+        registerSnapshot();
         addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet, sourceFile, lines);
     }
 }
@@ -88,28 +93,140 @@ function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColum
         ],
     });
 }
-export function collectDuplicateViolations(duplicates, limits) {
+function ensureFileSnapshot(fileSnapshots, filePath, normalizedLines, lines, sourceFile) {
+    if (fileSnapshots.has(filePath))
+        return;
+    fileSnapshots.set(filePath, {
+        sourceFile,
+        normalizedLines,
+        lines,
+    });
+}
+function fingerprintLine(entry) {
+    if (entry.normalized)
+        return entry.normalized;
+    const collapsed = entry.trimmed.replace(/\s+/g, ' ');
+    if (!collapsed)
+        return undefined;
+    if (!/[A-Za-z0-9]/.test(collapsed))
+        return undefined;
+    return collapsed.toLowerCase();
+}
+function buildOccurrenceInfo(occurrence, fileSnapshots) {
+    const snapshot = fileSnapshots.get(occurrence.file);
+    if (!snapshot)
+        return undefined;
+    const totalLines = snapshot.normalizedLines.length;
+    if (totalLines === 0)
+        return undefined;
+    const clampIndex = (value) => Math.max(0, Math.min(totalLines - 1, value));
+    const rawStart = clampIndex(occurrence.line - 1);
+    const rawEnd = clampIndex(occurrence.endLine - 1);
+    return {
+        file: occurrence.file,
+        snapshot,
+        startIndex: Math.min(rawStart, rawEnd),
+        endIndex: Math.max(rawStart, rawEnd),
+    };
+}
+function expandDuplicateTracker(tracker, fileSnapshots) {
+    const infos = tracker.occurrences
+        .map((occurrence) => buildOccurrenceInfo(occurrence, fileSnapshots))
+        .filter((info) => Boolean(info));
+    if (infos.length < 2)
+        return undefined;
+    expandRangeAcrossOccurrences(infos);
+    const primary = infos[0];
+    const lines = primary.snapshot.normalizedLines
+        .slice(primary.startIndex, primary.endIndex + 1)
+        .map((entry) => entry.trimmed)
+        .filter(Boolean);
+    if (!lines.length)
+        return undefined;
+    const snippet = lines.map((line) => line.replace(/\s+/g, ' ')).join('\n');
+    const startLine = primary.startIndex + 1;
+    const endLine = primary.endIndex + 1;
+    const startColumn = getLineColumnRange(primary.snapshot.normalizedLines[primary.startIndex].raw).startColumn;
+    const endColumn = getLineColumnRange(primary.snapshot.normalizedLines[primary.endIndex].raw).endColumn;
+    const requiredVariables = collectRequiredVariables(primary.snapshot.sourceFile, primary.snapshot.lines, {
+        startLine,
+        startColumn,
+        endLine,
+        endColumn,
+    });
+    return {
+        snippet,
+        detail: infos.map(formatOccurrenceDetail).join('\n'),
+        requiredVariables,
+    };
+}
+function expandRangeAcrossOccurrences(infos) {
+    while (tryExpandRange(infos, 'left')) { }
+    while (tryExpandRange(infos, 'right')) { }
+}
+function tryExpandRange(infos, direction) {
+    const fingerprints = [];
+    for (const info of infos) {
+        const nextIndex = direction === 'left' ? info.startIndex - 1 : info.endIndex + 1;
+        if (nextIndex < 0 || nextIndex >= info.snapshot.normalizedLines.length) {
+            return false;
+        }
+        const fingerprint = fingerprintLine(info.snapshot.normalizedLines[nextIndex]);
+        if (!fingerprint)
+            return false;
+        fingerprints.push(fingerprint);
+    }
+    if (fingerprints.some((value) => value !== fingerprints[0])) {
+        return false;
+    }
+    for (const info of infos) {
+        if (direction === 'left') {
+            info.startIndex -= 1;
+        }
+        else {
+            info.endIndex += 1;
+        }
+    }
+    return true;
+}
+function formatOccurrenceDetail(info) {
+    const startLine = info.startIndex + 1;
+    const endLine = info.endIndex + 1;
+    const startEntry = info.snapshot.normalizedLines[info.startIndex];
+    const endEntry = info.snapshot.normalizedLines[info.endIndex];
+    const startColumn = startEntry
+        ? getLineColumnRange(startEntry.raw).startColumn
+        : 1;
+    const endColumn = endEntry
+        ? getLineColumnRange(endEntry.raw).endColumn
+        : 1;
+    const relativePath = path.relative(process.cwd(), info.file);
+    return `${relativePath}:${startLine}:${startColumn}/${endLine}:${endColumn}`;
+}
+export function collectDuplicateViolations(duplicates, limits, fileSnapshots) {
     const violations = [];
     for (const tracker of duplicates.values()) {
         if (tracker.count <= limits.maxDuplicateLineOccurrences)
             continue;
         if (tracker.occurrences.length === 0)
             continue;
+        const expanded = expandDuplicateTracker(tracker, fileSnapshots);
         violations.push({
             type: 'duplicateLine',
             file: tracker.occurrences[0].file,
             line: tracker.occurrences[0].line,
             severity: tracker.count - limits.maxDuplicateLineOccurrences,
             message: `Repeated ${tracker.count} times (max ${limits.maxDuplicateLineOccurrences})`,
-            detail: tracker.occurrences
-                .map((occurrence) => {
-                const relativePath = path.relative(process.cwd(), occurrence.file);
-                return `${relativePath}:${occurrence.line}:${occurrence.startColumn}/${occurrence.endLine}:${occurrence.endColumn}`;
-            })
-                .join('\n'),
-            snippet: tracker.snippet,
+            detail: expanded?.detail ??
+                tracker.occurrences
+                    .map((occurrence) => {
+                    const relativePath = path.relative(process.cwd(), occurrence.file);
+                    return `${relativePath}:${occurrence.line}:${occurrence.startColumn}/${occurrence.endLine}:${occurrence.endColumn}`;
+                })
+                    .join('\n'),
+            snippet: expanded?.snippet ?? tracker.snippet,
             repeatCount: tracker.count,
-            requiredVariables: tracker.requiredVariables,
+            requiredVariables: expanded?.requiredVariables ?? tracker.requiredVariables,
         });
     }
     return violations;

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

@@ -12,13 +12,15 @@ export function collectFunctionRecords(sourceFile) {
             const length = end.line - start.line + 1;
             const name = resolveFunctionName(node);
             const isComponent = typeof name === 'string' && isComponentFunction(node, name);
-            const isExported = ts.isExportDeclaration(node);
+            const isMethod = ts.isMethodDeclaration(node);
+            const isExported = hasExportModifier(node) || (isMethod && isParentClassExported(node));
             records.push({
                 name,
                 startLine: start.line + 1,
                 length,
                 isComponent,
                 isExported,
+                isMethod,
             });
         }
         ts.forEachChild(node, visit);
@@ -66,3 +68,18 @@ function containsJsx(node) {
     ts.forEachChild(node, walk);
     return found;
 }
+function hasExportModifier(node) {
+    const candidate = node;
+    if (!candidate.modifiers)
+        return false;
+    return candidate.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+function isParentClassExported(node) {
+    const parent = node.parent;
+    if (!parent)
+        return false;
+    if (ts.isClassDeclaration(parent) || ts.isClassExpression(parent)) {
+        return hasExportModifier(parent);
+    }
+    return false;
+}

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

@@ -2,9 +2,11 @@ import path from 'node:path';
 import * as ts from 'typescript';
 export function normalizeLine(line) {
     const trimmed = line.trim();
-    if (trimmed.length < 12)
+    if (!trimmed)
         return undefined;
     const collapse = trimmed.replace(/\s+/g, ' ');
+    const letterCount = (collapse.match(/[A-Za-z]/g) ?? []).length;
+    // if (collapse.length < 12 && letterCount < 3) return undefined
     const noNumbers = collapse.replace(/\d+/g, '#');
     return noNumbers.toLowerCase();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",