@webpieces/code-rules 0.0.1 → 0.2.113

package/src/{validate-modified-methods.ts → validate-modified-methods.js}

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Validate Modified Methods Executor
  *
@@ -18,36 +19,15 @@
  * Format: // webpieces-disable max-lines-modified 2025/01/15 -- [reason]
  * The disable expires after 1 month from the date specified.
  */
-
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as ts from 'typescript';
-
-export type MethodMaxLimitMode = 'OFF' | 'NEW_METHODS' | 'NEW_AND_MODIFIED_METHODS' | 'MODIFIED_FILES';
-
-export interface ValidateModifiedMethodsOptions {
-    limit?: number;
-    mode?: MethodMaxLimitMode;
-    disableAllowed?: boolean;
-}
-
-export interface ExecutorResult {
-    success: boolean;
-}
-
-interface MethodViolation {
-    file: string;
-    methodName: string;
-    line: number;
-    lines: number;
-    expiredDisable?: boolean;
-    expiredDate?: string;
-}
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runValidator;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const ts = tslib_1.__importStar(require("typescript"));
 const TMP_DIR = '.webpieces/instruct-ai';
 const TMP_MD_FILE = 'webpieces.methodsize.md';
-
 const METHODSIZE_DOC_CONTENT = `# Instructions: Method Too Long
 
 ## Requirement
@@ -172,31 +152,27 @@ This ensures that disable comments are reviewed periodically.
 - The best code explains itself through structure
 - When in doubt, extract and name it
 `;
-
 /**
  * Write the instructions documentation to tmp directory
  */
-function writeTmpInstructions(workspaceRoot: string): string {
+function writeTmpInstructions(workspaceRoot) {
     const tmpDir = path.join(workspaceRoot, TMP_DIR);
     const mdPath = path.join(tmpDir, TMP_MD_FILE);
-
     fs.mkdirSync(tmpDir, { recursive: true });
     fs.writeFileSync(mdPath, METHODSIZE_DOC_CONTENT);
-
     return mdPath;
 }
-
 /**
  * Get changed TypeScript files between base and head (or working tree if head not specified).
  * Uses `git diff base [head]` to match what `nx affected` does.
  * When head is NOT specified, also includes untracked files (matching nx affected behavior).
  */
-function getChangedTypeScriptFiles(workspaceRoot: string, base: string, head?: string): string[] {
+function getChangedTypeScriptFiles(workspaceRoot, base, head) {
     // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
     try {
         // If head is specified, diff base to head; otherwise diff base to working tree
         const diffTarget = head ? `${base} ${head}` : base;
-        const output = execSync(`git diff --name-only ${diffTarget} -- '*.ts' '*.tsx'`, {
+        const output = (0, child_process_1.execSync)(`git diff --name-only ${diffTarget} -- '*.ts' '*.tsx'`, {
             cwd: workspaceRoot,
             encoding: 'utf-8',
         });
@@ -204,13 +180,12 @@ function getChangedTypeScriptFiles(workspaceRoot: string, base: string, head?: s
             .trim()
             .split('\n')
             .filter((f) => f && !f.includes('.spec.ts') && !f.includes('.test.ts'));
-
         // When comparing to working tree (no head specified), also include untracked files
         // This matches what nx affected does: "All modified files not yet committed or tracked will also be added"
         if (!head) {
             // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
             try {
-                const untrackedOutput = execSync(`git ls-files --others --exclude-standard '*.ts' '*.tsx'`, {
+                const untrackedOutput = (0, child_process_1.execSync)(`git ls-files --others --exclude-standard '*.ts' '*.tsx'`, {
                     cwd: workspaceRoot,
                     encoding: 'utf-8',
                 });
@@ -221,45 +196,43 @@ function getChangedTypeScriptFiles(workspaceRoot: string, base: string, head?: s
                 // Merge and dedupe
                 const allFiles = new Set([...changedFiles, ...untrackedFiles]);
                 return Array.from(allFiles);
-            } catch (err: unknown) {
+            }
+            catch (err) {
                 //const error = toError(err);
                 // If ls-files fails, just return the changed files
                 return changedFiles;
             }
         }
-
         return changedFiles;
-    } catch (err: unknown) {
+    }
+    catch (err) {
         //const error = toError(err);
         return [];
     }
 }
-
 /**
  * Get the diff content for a specific file between base and head (or working tree if head not specified).
  * Uses `git diff base [head]` to match what `nx affected` does.
  * For untracked files, returns the entire file content as additions.
  */
-function getFileDiff(workspaceRoot: string, file: string, base: string, head?: string): string {
+function getFileDiff(workspaceRoot, file, base, head) {
     // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
     try {
         // If head is specified, diff base to head; otherwise diff base to working tree
         const diffTarget = head ? `${base} ${head}` : base;
-        const diff = execSync(`git diff ${diffTarget} -- "${file}"`, {
+        const diff = (0, child_process_1.execSync)(`git diff ${diffTarget} -- "${file}"`, {
             cwd: workspaceRoot,
             encoding: 'utf-8',
         });
-
         // If diff is empty and we're comparing to working tree, check if it's an untracked file
         if (!diff && !head) {
             const fullPath = path.join(workspaceRoot, file);
             if (fs.existsSync(fullPath)) {
                 // Check if file is untracked
-                const isUntracked = execSync(`git ls-files --others --exclude-standard "${file}"`, {
+                const isUntracked = (0, child_process_1.execSync)(`git ls-files --others --exclude-standard "${file}"`, {
                     cwd: workspaceRoot,
                     encoding: 'utf-8',
                 }).trim();
-
                 if (isUntracked) {
                     // For untracked files, treat entire content as additions
                     const content = fs.readFileSync(fullPath, 'utf-8');
@@ -269,23 +242,21 @@ function getFileDiff(workspaceRoot: string, file: string, base: string, head?: s
                 }
             }
         }
-
         return diff;
-    } catch (err: unknown) {
+    }
+    catch (err) {
         //const error = toError(err);
         return '';
     }
 }
-
 /**
  * Parse diff to find NEW method signatures.
  * Must handle: export function, async function, const/let arrow functions, class methods
  */
 // webpieces-disable max-lines-new-methods -- Regex patterns require inline documentation
-function findNewMethodSignaturesInDiff(diffContent: string): Set<string> {
-    const newMethods = new Set<string>();
+function findNewMethodSignaturesInDiff(diffContent) {
+    const newMethods = new Set();
     const lines = diffContent.split('\n');
-
     // Patterns to match method definitions (same as validate-new-methods)
     const patterns = [
         // [export] [async] function methodName( - most explicit, check first
@@ -297,7 +268,6 @@ function findNewMethodSignaturesInDiff(diffContent: string): Set<string> {
         // class method: [public/private/protected] [static] [async] methodName( - but NOT constructor, if, for, while, etc.
         /^\+\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:async\s+)?(\w+)\s*\(/,
     ];
-
     for (const line of lines) {
         if (line.startsWith('+') && !line.startsWith('+++')) {
             for (const pattern of patterns) {
@@ -313,19 +283,15 @@ function findNewMethodSignaturesInDiff(diffContent: string): Set<string> {
             }
         }
     }
-
     return newMethods;
 }
-
 /**
  * Parse diff to find line numbers that have changes in the new file
  */
-function getChangedLineNumbers(diffContent: string): Set<number> {
-    const changedLines = new Set<number>();
+function getChangedLineNumbers(diffContent) {
+    const changedLines = new Set();
     const lines = diffContent.split('\n');
-
     let currentNewLine = 0;
-
     for (const line of lines) {
         // Parse hunk header: @@ -oldStart,oldCount +newStart,newCount @@
         const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
@@ -333,73 +299,60 @@ function getChangedLineNumbers(diffContent: string): Set<number> {
             currentNewLine = parseInt(hunkMatch[1], 10);
             continue;
         }
-
-        if (currentNewLine === 0) continue;
-
+        if (currentNewLine === 0)
+            continue;
         if (line.startsWith('+') && !line.startsWith('+++')) {
             // Added line
             changedLines.add(currentNewLine);
             currentNewLine++;
-        } else if (line.startsWith('-') && !line.startsWith('---')) {
+        }
+        else if (line.startsWith('-') && !line.startsWith('---')) {
             // Removed line - doesn't increment new line counter
-        } else if (!line.startsWith('\\')) {
+        }
+        else if (!line.startsWith('\\')) {
             // Context line (unchanged)
             currentNewLine++;
         }
     }
-
     return changedLines;
 }
-
 /**
  * Parse a date string in yyyy/mm/dd format and return a Date object.
  * Returns null if the format is invalid.
  */
-function parseDisableDate(dateStr: string): Date | null {
+function parseDisableDate(dateStr) {
     // Match yyyy/mm/dd format
     const match = dateStr.match(/^(\d{4})\/(\d{2})\/(\d{2})$/);
-    if (!match) return null;
-
+    if (!match)
+        return null;
     const year = parseInt(match[1], 10);
     const month = parseInt(match[2], 10) - 1; // JS months are 0-indexed
     const day = parseInt(match[3], 10);
-
     const date = new Date(year, month, day);
-
     // Validate the date is valid (e.g., not Feb 30)
     if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) {
         return null;
     }
-
     return date;
 }
-
 /**
  * Check if a date is within the last month (not expired).
  */
-function isDateWithinMonth(date: Date): boolean {
+function isDateWithinMonth(date) {
     const now = new Date();
     const oneMonthAgo = new Date(now.getFullYear(), now.getMonth() - 1, now.getDate());
     return date >= oneMonthAgo;
 }
-
 /**
  * Get today's date in yyyy/mm/dd format for error messages
  */
-function getTodayDateString(): string {
+function getTodayDateString() {
     const now = new Date();
     const year = now.getFullYear();
     const month = String(now.getMonth() + 1).padStart(2, '0');
     const day = String(now.getDate()).padStart(2, '0');
     return `${year}/${month}/${day}`;
 }
-
-interface DisableInfo {
-    type: 'full' | 'new-only' | 'none';
-    isExpired: boolean;
-    date?: string;
-}
-
 /**
  * Check what kind of webpieces-disable comment is present for a method.
  * Returns: DisableInfo with type, expiration status, and date
@@ -408,7 +361,7 @@ interface DisableInfo {
  * - 'none': no escape hatch
  */
 // webpieces-disable max-lines-new-methods -- Complex validation logic with multiple escape hatch types
-function getDisableInfo(lines: string[], lineNumber: number): DisableInfo {
+function getDisableInfo(lines, lineNumber) {
     const startCheck = Math.max(0, lineNumber - 5);
     for (let i = lineNumber - 2; i >= startCheck; i--) {
         const line = lines[i]?.trim() ?? '';
@@ -419,60 +372,48 @@ function getDisableInfo(lines: string[], lineNumber: number): DisableInfo {
             if (line.includes('max-lines-modified')) {
                 // Check for date in format: max-lines-modified yyyy/mm/dd
                 const dateMatch = line.match(/max-lines-modified\s+(\d{4}\/\d{2}\/\d{2}|XXXX\/XX\/XX)/);
-
                 if (!dateMatch) {
                     // No date found - treat as expired (invalid)
                     return { type: 'full', isExpired: true, date: undefined };
                 }
-
                 const dateStr = dateMatch[1];
-
                 // Secret permanent disable
                 if (dateStr === 'XXXX/XX/XX') {
                     return { type: 'full', isExpired: false, date: dateStr };
                 }
-
                 const date = parseDisableDate(dateStr);
                 if (!date) {
                     // Invalid date format - treat as expired
                     return { type: 'full', isExpired: true, date: dateStr };
                 }
-
                 if (!isDateWithinMonth(date)) {
                     // Date is expired (older than 1 month)
                     return { type: 'full', isExpired: true, date: dateStr };
                 }
-
                 // Valid and not expired
                 return { type: 'full', isExpired: false, date: dateStr };
             }
             if (line.includes('max-lines-new-methods')) {
                 // Check for date in format: max-lines-new-methods yyyy/mm/dd
                 const dateMatch = line.match(/max-lines-new-methods\s+(\d{4}\/\d{2}\/\d{2}|XXXX\/XX\/XX)/);
-
                 if (!dateMatch) {
                     // No date found - treat as expired (invalid)
                     return { type: 'new-only', isExpired: true, date: undefined };
                 }
-
                 const dateStr = dateMatch[1];
-
                 // Secret permanent disable
                 if (dateStr === 'XXXX/XX/XX') {
                     return { type: 'new-only', isExpired: false, date: dateStr };
                 }
-
                 const date = parseDisableDate(dateStr);
                 if (!date) {
                     // Invalid date format - treat as expired
                     return { type: 'new-only', isExpired: true, date: dateStr };
                 }
-
                 if (!isDateWithinMonth(date)) {
                     // Date is expired (older than 1 month)
                     return { type: 'new-only', isExpired: true, date: dateStr };
                 }
-
                 // Valid and not expired
                 return { type: 'new-only', isExpired: false, date: dateStr };
             }
@@ -480,48 +421,38 @@ function getDisableInfo(lines: string[], lineNumber: number): DisableInfo {
     }
     return { type: 'none', isExpired: false };
 }
-
-interface MethodInfo {
-    name: string;
-    line: number;
-    endLine: number;
-    lines: number;
-    disableInfo: DisableInfo;
-}
-
 /**
  * Parse a TypeScript file and find methods with their line counts
  */
 // webpieces-disable max-lines-new-methods -- AST traversal requires inline visitor function
-function findMethodsInFile(filePath: string, workspaceRoot: string): MethodInfo[] {
+function findMethodsInFile(filePath, workspaceRoot) {
     const fullPath = path.join(workspaceRoot, filePath);
-    if (!fs.existsSync(fullPath)) return [];
-
+    if (!fs.existsSync(fullPath))
+        return [];
     const content = fs.readFileSync(fullPath, 'utf-8');
     const fileLines = content.split('\n');
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-
-    const methods: MethodInfo[] = [];
-
+    const methods = [];
     // webpieces-disable max-lines-new-methods -- AST visitor pattern requires handling multiple node types
-    function visit(node: ts.Node): void {
-        let methodName: string | undefined;
-        let startLine: number | undefined;
-        let endLine: number | undefined;
-
+    function visit(node) {
+        let methodName;
+        let startLine;
+        let endLine;
         if (ts.isMethodDeclaration(node) && node.name) {
             methodName = node.name.getText(sourceFile);
             const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
             startLine = start.line + 1;
             endLine = end.line + 1;
-        } else if (ts.isFunctionDeclaration(node) && node.name) {
+        }
+        else if (ts.isFunctionDeclaration(node) && node.name) {
             methodName = node.name.getText(sourceFile);
             const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
             startLine = start.line + 1;
             endLine = end.line + 1;
-        } else if (ts.isArrowFunction(node)) {
+        }
+        else if (ts.isArrowFunction(node)) {
             if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 methodName = node.parent.name.getText(sourceFile);
                 const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
@@ -530,7 +461,6 @@ function findMethodsInFile(filePath: string, workspaceRoot: string): MethodInfo[
                 endLine = end.line + 1;
             }
         }
-
         if (methodName && startLine !== undefined && endLine !== undefined) {
             methods.push({
                 name: methodName,
@@ -540,57 +470,51 @@ function findMethodsInFile(filePath: string, workspaceRoot: string): MethodInfo[
                 disableInfo: getDisableInfo(fileLines, startLine),
             });
         }
-
         ts.forEachChild(node, visit);
     }
-
     visit(sourceFile);
     return methods;
 }
-
 /**
  * Check if a method has any changes within its line range
  */
-function methodHasChanges(method: MethodInfo, changedLineNumbers: Set<number>): boolean {
+function methodHasChanges(method, changedLineNumbers) {
     for (let line = method.line; line <= method.endLine; line++) {
-        if (changedLineNumbers.has(line)) return true;
+        if (changedLineNumbers.has(line))
+            return true;
     }
     return false;
 }
-
 /**
  * Check a NEW method and return violation if applicable
  */
-function checkNewMethodViolation(file: string, method: MethodInfo, disableAllowed: boolean): MethodViolation | null {
+function checkNewMethodViolation(file, method, disableAllowed) {
     const disableType = method.disableInfo.type;
     const isExpired = method.disableInfo.isExpired;
     const disableDate = method.disableInfo.date;
-
     if (!disableAllowed) {
         // When disableAllowed is false, skip NEW methods without escape (let validate-new-methods handle)
-        if (disableType === 'none') return null;
+        if (disableType === 'none')
+            return null;
         return { file, methodName: method.name, line: method.line, lines: method.lines };
     }
-
     if (disableType === 'full' && isExpired) {
         return { file, methodName: method.name, line: method.line, lines: method.lines, expiredDisable: true, expiredDate: disableDate };
     }
-    if (disableType !== 'new-only') return null;
-
+    if (disableType !== 'new-only')
+        return null;
     if (isExpired) {
         return { file, methodName: method.name, line: method.line, lines: method.lines, expiredDisable: true, expiredDate: disableDate };
     }
     return { file, methodName: method.name, line: method.line, lines: method.lines };
 }
-
 /**
  * Check a MODIFIED method and return violation if applicable
  */
-function checkModifiedMethodViolation(file: string, method: MethodInfo, disableAllowed: boolean): MethodViolation | null {
+function checkModifiedMethodViolation(file, method, disableAllowed) {
     const disableType = method.disableInfo.type;
     const isExpired = method.disableInfo.isExpired;
     const disableDate = method.disableInfo.date;
-
     if (!disableAllowed) {
         return { file, methodName: method.name, line: method.line, lines: method.lines };
     }
@@ -603,95 +527,84 @@ function checkModifiedMethodViolation(file: string, method: MethodInfo, disableA
     }
     return { file, methodName: method.name, line: method.line, lines: method.lines };
 }
-
 /**
  * Find methods that exceed the limit.
  * Checks NEW methods with escape hatches and MODIFIED methods.
  */
-function findViolations(
-    workspaceRoot: string,
-    changedFiles: string[],
-    base: string,
-    limit: number,
-    disableAllowed: boolean,
-    head?: string
-): MethodViolation[] {
-    const violations: MethodViolation[] = [];
-
+function findViolations(workspaceRoot, changedFiles, base, limit, disableAllowed, head) {
+    const violations = [];
     for (const file of changedFiles) {
         const diff = getFileDiff(workspaceRoot, file, base, head);
-        if (!diff) continue;
-
+        if (!diff)
+            continue;
         const newMethodNames = findNewMethodSignaturesInDiff(diff);
         const changedLineNumbers = getChangedLineNumbers(diff);
-        if (changedLineNumbers.size === 0) continue;
-
+        if (changedLineNumbers.size === 0)
+            continue;
         const methods = findMethodsInFile(file, workspaceRoot);
-
         for (const method of methods) {
             const disableType = method.disableInfo.type;
             const isExpired = method.disableInfo.isExpired;
-
             // Skip methods with valid, non-expired full escape - unless disableAllowed is false
-            if (disableAllowed && disableType === 'full' && !isExpired) continue;
-            if (method.lines <= limit) continue;
-
+            if (disableAllowed && disableType === 'full' && !isExpired)
+                continue;
+            if (method.lines <= limit)
+                continue;
             const isNewMethod = newMethodNames.has(method.name);
-
             if (isNewMethod) {
                 const violation = checkNewMethodViolation(file, method, disableAllowed);
-                if (violation) violations.push(violation);
-            } else if (methodHasChanges(method, changedLineNumbers)) {
+                if (violation)
+                    violations.push(violation);
+            }
+            else if (methodHasChanges(method, changedLineNumbers)) {
                 const violation = checkModifiedMethodViolation(file, method, disableAllowed);
-                if (violation) violations.push(violation);
+                if (violation)
+                    violations.push(violation);
             }
         }
     }
-
     return violations;
 }
-
 /**
  * Auto-detect the base branch by finding the merge-base with origin/main.
  */
-function detectBase(workspaceRoot: string): string | null {
+function detectBase(workspaceRoot) {
     // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
     try {
-        const mergeBase = execSync('git merge-base HEAD origin/main', {
+        const mergeBase = (0, child_process_1.execSync)('git merge-base HEAD origin/main', {
             cwd: workspaceRoot,
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe'],
         }).trim();
-
         if (mergeBase) {
             return mergeBase;
         }
-    } catch (err: unknown) {
+    }
+    catch (err) {
         //const error = toError(err);
         // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
         try {
-            const mergeBase = execSync('git merge-base HEAD main', {
+            const mergeBase = (0, child_process_1.execSync)('git merge-base HEAD main', {
                 cwd: workspaceRoot,
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
             }).trim();
-
             if (mergeBase) {
                 return mergeBase;
             }
-        } catch (err2: unknown) {
+        }
+        catch (err2) {
             //const error2 = toError(err2);
             // Ignore
         }
     }
     return null;
 }
-
 /**
  * Report violations to console
  */
 // webpieces-disable max-lines-new-methods -- Error output formatting with multiple message sections
-function reportViolations(violations: MethodViolation[], limit: number, disableAllowed: boolean): void {
+function reportViolations(violations, limit, disableAllowed) {
     console.error('');
     console.error('\u274c Modified methods exceed ' + limit + ' lines!');
     console.error('');
@@ -701,24 +614,21 @@ function reportViolations(violations: MethodViolation[], limit: number, disableA
     console.error('   (this is for vibe coding and AI to fix as it touches things).');
     console.error('   You can refactor to stay under the limit 50% of the time. If not feasible, use the escape hatch.');
     console.error('');
-    console.error(
-        '\u26a0\ufe0f  *** READ .webpieces/instruct-ai/webpieces.methodsize.md for detailed guidance on how to fix this easily *** \u26a0\ufe0f'
-    );
+    console.error('\u26a0\ufe0f  *** READ .webpieces/instruct-ai/webpieces.methodsize.md for detailed guidance on how to fix this easily *** \u26a0\ufe0f');
     console.error('');
-
     for (const v of violations) {
         if (v.expiredDisable) {
             console.error(`  \u274c ${v.file}:${v.line}`);
             console.error(`     Method: ${v.methodName} (${v.lines} lines, max: ${limit})`);
             console.error(`     \u23f0 EXPIRED DISABLE: Your disable comment dated ${v.expiredDate ?? 'unknown'} has expired (>1 month old).`);
             console.error(`        You must either FIX the method or UPDATE the date to get another month.`);
-        } else {
+        }
+        else {
             console.error(`  \u274c ${v.file}:${v.line}`);
             console.error(`     Method: ${v.methodName} (${v.lines} lines, max: ${limit})`);
         }
     }
     console.error('');
-
     // Only show escape hatch instructions when disableAllowed is true
     if (disableAllowed) {
         console.error('   You can disable this error, but you will be forced to fix again in 1 month');
@@ -727,7 +637,8 @@ function reportViolations(violations: MethodViolation[], limit: number, disableA
         console.error('   Use escape with DATE (expires in 1 month):');
         console.error(`   // webpieces-disable max-lines-modified ${getTodayDateString()} -- [your reason]`);
         console.error('');
-    } else {
+    }
+    else {
         console.error('   \u26a0\ufe0f  disableAllowed is false - disable comments are NOT allowed.');
         console.error('   This rule must be met and cannot be disabled since nx.json disableAllowed is set to false.');
         console.error('   You MUST refactor to reduce method size.');
@@ -740,73 +651,60 @@ function reportViolations(violations: MethodViolation[], limit: number, disableA
         console.error('');
     }
 }
-
-export default async function runValidator(
-    options: ValidateModifiedMethodsOptions,
-    workspaceRoot: string
-): Promise<ExecutorResult> {
+async function runValidator(options, workspaceRoot) {
     const limit = options.limit ?? 80;
-    const mode: MethodMaxLimitMode = options.mode ?? 'NEW_AND_MODIFIED_METHODS';
+    const mode = options.mode ?? 'NEW_AND_MODIFIED_METHODS';
     const disableAllowed = options.disableAllowed ?? true;
-
     // Skip validation entirely if mode is OFF
     if (mode === 'OFF') {
         console.log('\n\u23ed\ufe0f  Skipping modified method validation (mode: OFF)');
         console.log('');
         return { success: true };
     }
-
     // If NX_HEAD is set (via nx affected --head=X), use it; otherwise compare to working tree
     let base = process.env['NX_BASE'];
     const head = process.env['NX_HEAD'];
-
     if (!base) {
         base = detectBase(workspaceRoot) ?? undefined;
-
         if (!base) {
             console.log('\n\u23ed\ufe0f  Skipping modified method validation (could not detect base branch)');
             console.log('   To run explicitly: nx affected --target=validate-modified-methods --base=origin/main');
             console.log('');
             return { success: true };
         }
-
         console.log('\n\ud83d\udccf Validating Modified Method Sizes (auto-detected base)\n');
-    } else {
+    }
+    else {
         console.log('\n\ud83d\udccf Validating Modified Method Sizes\n');
     }
-
     console.log(`   Base: ${base}`);
     console.log(`   Head: ${head ?? 'working tree (includes uncommitted changes)'}`);
     console.log(`   Mode: ${mode}`);
     console.log(`   Limit for modified methods: ${limit}`);
     console.log(`   Disable allowed: ${disableAllowed}${!disableAllowed ? ' (no escape hatch)' : ''}`);
     console.log('');
-
     // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
     try {
         const changedFiles = getChangedTypeScriptFiles(workspaceRoot, base, head);
-
         if (changedFiles.length === 0) {
             console.log('\u2705 No TypeScript files changed');
             return { success: true };
         }
-
         console.log(`\ud83d\udcc2 Checking ${changedFiles.length} changed file(s)...`);
-
         const violations = findViolations(workspaceRoot, changedFiles, base, limit, disableAllowed, head);
-
         if (violations.length === 0) {
             console.log('\u2705 All modified methods are under ' + limit + ' lines');
             return { success: true };
         }
-
         writeTmpInstructions(workspaceRoot);
         reportViolations(violations, limit, disableAllowed);
         return { success: false };
-    } catch (err: unknown) {
+    }
+    catch (err) {
         //const error = toError(err);
         const error = err instanceof Error ? err : new Error(String(err));
         console.error('\u274c Modified method validation failed:', error.message);
         return { success: false };
     }
 }
+//# sourceMappingURL=validate-modified-methods.js.map